diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/__init__.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/__init__.py index 9978135e2bfb..c9f9d8d6e8f6 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/__init__.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/__init__.py @@ -30,25 +30,32 @@ CapacityCommitment, CreateAssignmentRequest, CreateCapacityCommitmentRequest, + CreateReservationGroupRequest, CreateReservationRequest, DeleteAssignmentRequest, DeleteCapacityCommitmentRequest, + DeleteReservationGroupRequest, DeleteReservationRequest, Edition, FailoverMode, FailoverReservationRequest, GetBiReservationRequest, GetCapacityCommitmentRequest, + GetReservationGroupRequest, GetReservationRequest, ListAssignmentsRequest, ListAssignmentsResponse, ListCapacityCommitmentsRequest, ListCapacityCommitmentsResponse, + ListReservationGroupsRequest, + ListReservationGroupsResponse, ListReservationsRequest, ListReservationsResponse, MergeCapacityCommitmentsRequest, MoveAssignmentRequest, Reservation, + ReservationGroup, + SchedulingPolicy, SearchAllAssignmentsRequest, SearchAllAssignmentsResponse, SearchAssignmentsRequest, @@ -70,23 +77,30 @@ "CapacityCommitment", "CreateAssignmentRequest", "CreateCapacityCommitmentRequest", + "CreateReservationGroupRequest", "CreateReservationRequest", "DeleteAssignmentRequest", "DeleteCapacityCommitmentRequest", + "DeleteReservationGroupRequest", "DeleteReservationRequest", "FailoverReservationRequest", "GetBiReservationRequest", "GetCapacityCommitmentRequest", + "GetReservationGroupRequest", "GetReservationRequest", "ListAssignmentsRequest", "ListAssignmentsResponse", "ListCapacityCommitmentsRequest", "ListCapacityCommitmentsResponse", + "ListReservationGroupsRequest", + "ListReservationGroupsResponse", "ListReservationsRequest", "ListReservationsResponse", "MergeCapacityCommitmentsRequest", "MoveAssignmentRequest", "Reservation", + "ReservationGroup", + "SchedulingPolicy", "SearchAllAssignmentsRequest", "SearchAllAssignmentsResponse", "SearchAssignmentsRequest", diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/gapic_version.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/gapic_version.py index 7313c97c3096..20a9cd975b02 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/gapic_version.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "1.19.0" # {x-release-please-version} +__version__ = "0.0.0" # {x-release-please-version} diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/__init__.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/__init__.py index 3f0402d98d56..5d423369dc78 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/__init__.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/__init__.py @@ -28,25 +28,32 @@ CapacityCommitment, CreateAssignmentRequest, CreateCapacityCommitmentRequest, + CreateReservationGroupRequest, CreateReservationRequest, DeleteAssignmentRequest, DeleteCapacityCommitmentRequest, + DeleteReservationGroupRequest, DeleteReservationRequest, Edition, FailoverMode, FailoverReservationRequest, GetBiReservationRequest, GetCapacityCommitmentRequest, + GetReservationGroupRequest, GetReservationRequest, ListAssignmentsRequest, ListAssignmentsResponse, ListCapacityCommitmentsRequest, ListCapacityCommitmentsResponse, + ListReservationGroupsRequest, + ListReservationGroupsResponse, ListReservationsRequest, ListReservationsResponse, MergeCapacityCommitmentsRequest, MoveAssignmentRequest, Reservation, + ReservationGroup, + SchedulingPolicy, SearchAllAssignmentsRequest, SearchAllAssignmentsResponse, SearchAssignmentsRequest, @@ -67,26 +74,33 @@ "CapacityCommitment", "CreateAssignmentRequest", "CreateCapacityCommitmentRequest", + "CreateReservationGroupRequest", "CreateReservationRequest", "DeleteAssignmentRequest", "DeleteCapacityCommitmentRequest", + "DeleteReservationGroupRequest", "DeleteReservationRequest", "Edition", "FailoverMode", "FailoverReservationRequest", "GetBiReservationRequest", "GetCapacityCommitmentRequest", + "GetReservationGroupRequest", "GetReservationRequest", "ListAssignmentsRequest", "ListAssignmentsResponse", "ListCapacityCommitmentsRequest", "ListCapacityCommitmentsResponse", + "ListReservationGroupsRequest", + "ListReservationGroupsResponse", "ListReservationsRequest", "ListReservationsResponse", "MergeCapacityCommitmentsRequest", "MoveAssignmentRequest", "Reservation", + "ReservationGroup", "ReservationServiceClient", + "SchedulingPolicy", "SearchAllAssignmentsRequest", "SearchAllAssignmentsResponse", "SearchAssignmentsRequest", diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_metadata.json b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_metadata.json index 385c3265ef89..7216bd76bb22 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_metadata.json +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_metadata.json @@ -25,6 +25,11 @@ "create_reservation" ] }, + "CreateReservationGroup": { + "methods": [ + "create_reservation_group" + ] + }, "DeleteAssignment": { "methods": [ "delete_assignment" @@ -40,6 +45,11 @@ "delete_reservation" ] }, + "DeleteReservationGroup": { + "methods": [ + "delete_reservation_group" + ] + }, "FailoverReservation": { "methods": [ "failover_reservation" @@ -55,11 +65,21 @@ "get_capacity_commitment" ] }, + "GetIamPolicy": { + "methods": [ + "get_iam_policy" + ] + }, "GetReservation": { "methods": [ "get_reservation" ] }, + "GetReservationGroup": { + "methods": [ + "get_reservation_group" + ] + }, "ListAssignments": { "methods": [ "list_assignments" @@ -70,6 +90,11 @@ "list_capacity_commitments" ] }, + "ListReservationGroups": { + "methods": [ + "list_reservation_groups" + ] + }, "ListReservations": { "methods": [ "list_reservations" @@ -95,11 +120,21 @@ "search_assignments" ] }, + "SetIamPolicy": { + "methods": [ + "set_iam_policy" + ] + }, "SplitCapacityCommitment": { "methods": [ "split_capacity_commitment" ] }, + "TestIamPermissions": { + "methods": [ + "test_iam_permissions" + ] + }, "UpdateAssignment": { "methods": [ "update_assignment" @@ -140,6 +175,11 @@ "create_reservation" ] }, + "CreateReservationGroup": { + "methods": [ + "create_reservation_group" + ] + }, "DeleteAssignment": { "methods": [ "delete_assignment" @@ -155,6 +195,11 @@ "delete_reservation" ] }, + "DeleteReservationGroup": { + "methods": [ + "delete_reservation_group" + ] + }, "FailoverReservation": { "methods": [ "failover_reservation" @@ -170,11 +215,21 @@ "get_capacity_commitment" ] }, + "GetIamPolicy": { + "methods": [ + "get_iam_policy" + ] + }, "GetReservation": { "methods": [ "get_reservation" ] }, + "GetReservationGroup": { + "methods": [ + "get_reservation_group" + ] + }, "ListAssignments": { "methods": [ "list_assignments" @@ -185,6 +240,11 @@ "list_capacity_commitments" ] }, + "ListReservationGroups": { + "methods": [ + "list_reservation_groups" + ] + }, "ListReservations": { "methods": [ "list_reservations" @@ -210,11 +270,21 @@ "search_assignments" ] }, + "SetIamPolicy": { + "methods": [ + "set_iam_policy" + ] + }, "SplitCapacityCommitment": { "methods": [ "split_capacity_commitment" ] }, + "TestIamPermissions": { + "methods": [ + "test_iam_permissions" + ] + }, "UpdateAssignment": { "methods": [ "update_assignment" @@ -255,6 +325,11 @@ "create_reservation" ] }, + "CreateReservationGroup": { + "methods": [ + "create_reservation_group" + ] + }, "DeleteAssignment": { "methods": [ "delete_assignment" @@ -270,6 +345,11 @@ "delete_reservation" ] }, + "DeleteReservationGroup": { + "methods": [ + "delete_reservation_group" + ] + }, "FailoverReservation": { "methods": [ "failover_reservation" @@ -285,11 +365,21 @@ "get_capacity_commitment" ] }, + "GetIamPolicy": { + "methods": [ + "get_iam_policy" + ] + }, "GetReservation": { "methods": [ "get_reservation" ] }, + "GetReservationGroup": { + "methods": [ + "get_reservation_group" + ] + }, "ListAssignments": { "methods": [ "list_assignments" @@ -300,6 +390,11 @@ "list_capacity_commitments" ] }, + "ListReservationGroups": { + "methods": [ + "list_reservation_groups" + ] + }, "ListReservations": { "methods": [ "list_reservations" @@ -325,11 +420,21 @@ "search_assignments" ] }, + "SetIamPolicy": { + "methods": [ + "set_iam_policy" + ] + }, "SplitCapacityCommitment": { "methods": [ "split_capacity_commitment" ] }, + "TestIamPermissions": { + "methods": [ + "test_iam_permissions" + ] + }, "UpdateAssignment": { "methods": [ "update_assignment" diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_version.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_version.py index 7313c97c3096..20a9cd975b02 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_version.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "1.19.0" # {x-release-please-version} +__version__ = "0.0.0" # {x-release-please-version} diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/async_client.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/async_client.py index ca32eed92ed5..f398519c989f 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/async_client.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/async_client.py @@ -45,6 +45,8 @@ except AttributeError: # pragma: NO COVER OptionalRetry = Union[retries.AsyncRetry, object, None] # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from google.rpc import status_pb2 # type: ignore @@ -111,6 +113,12 @@ class ReservationServiceAsyncClient: parse_reservation_path = staticmethod( ReservationServiceClient.parse_reservation_path ) + reservation_group_path = staticmethod( + ReservationServiceClient.reservation_group_path + ) + parse_reservation_group_path = staticmethod( + ReservationServiceClient.parse_reservation_group_path + ) common_billing_account_path = staticmethod( ReservationServiceClient.common_billing_account_path ) @@ -3189,6 +3197,836 @@ async def sample_update_bi_reservation(): # Done; return the response. return response + async def get_iam_policy( + self, + request: Optional[Union[iam_policy_pb2.GetIamPolicyRequest, dict]] = None, + *, + resource: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Gets the access control policy for a resource. May return: + + - A\ ``NOT_FOUND`` error if the resource doesn't exist or you + don't have the permission to view it. + - An empty policy if the resource exists but doesn't have a set + policy. + + Supported resources are: + + - Reservations + - ReservationAssignments + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.getIamPolicy`` to get + policies on reservations. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + from google.iam.v1 import iam_policy_pb2 # type: ignore + + async def sample_get_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = iam_policy_pb2.GetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = await client.get_iam_policy(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.iam.v1.iam_policy_pb2.GetIamPolicyRequest, dict]]): + The request object. Request message for ``GetIamPolicy`` method. + resource (:class:`str`): + REQUIRED: The resource for which the + policy is being requested. See the + operation documentation for the + appropriate value for this field. + + This corresponds to the ``resource`` 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.iam.v1.policy_pb2.Policy: + An Identity and Access Management (IAM) policy, which specifies access + controls for Google Cloud resources. + + A Policy is a collection of bindings. A binding binds + one or more members, or principals, to a single role. + Principals can be user accounts, service accounts, + Google groups, and domains (such as G Suite). A role + is a named list of permissions; each role can be an + IAM predefined role or a user-created custom role. + + For some types of Google Cloud resources, a binding + can also specify a condition, which is a logical + expression that allows access to a resource only if + the expression evaluates to true. A condition can add + constraints based on attributes of the request, the + resource, or both. To learn which resources support + conditions in their IAM policies, see the [IAM + documentation](https://cloud.google.com/iam/help/conditions/resource-policies). + + **JSON example:** + + :literal:`` { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag": "BwWWja0YfJA=", "version": 3 }`\ \` + + **YAML example:** + + :literal:`` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3`\ \` + + For a description of IAM and its features, see the + [IAM + documentation](https://cloud.google.com/iam/docs/). + + """ + # 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 = [resource] + 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." + ) + + # - The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.GetIamPolicyRequest(**request) + elif not request: + request = iam_policy_pb2.GetIamPolicyRequest(resource=resource) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.get_iam_policy + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def set_iam_policy( + self, + request: Optional[Union[iam_policy_pb2.SetIamPolicyRequest, dict]] = None, + *, + resource: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Sets an access control policy for a resource. Replaces any + existing policy. + + Supported resources are: + + - Reservations + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.setIamPolicy`` to set + policies on reservations. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + from google.iam.v1 import iam_policy_pb2 # type: ignore + + async def sample_set_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = iam_policy_pb2.SetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = await client.set_iam_policy(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.iam.v1.iam_policy_pb2.SetIamPolicyRequest, dict]]): + The request object. Request message for ``SetIamPolicy`` method. + resource (:class:`str`): + REQUIRED: The resource for which the + policy is being specified. See the + operation documentation for the + appropriate value for this field. + + This corresponds to the ``resource`` 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.iam.v1.policy_pb2.Policy: + An Identity and Access Management (IAM) policy, which specifies access + controls for Google Cloud resources. + + A Policy is a collection of bindings. A binding binds + one or more members, or principals, to a single role. + Principals can be user accounts, service accounts, + Google groups, and domains (such as G Suite). A role + is a named list of permissions; each role can be an + IAM predefined role or a user-created custom role. + + For some types of Google Cloud resources, a binding + can also specify a condition, which is a logical + expression that allows access to a resource only if + the expression evaluates to true. A condition can add + constraints based on attributes of the request, the + resource, or both. To learn which resources support + conditions in their IAM policies, see the [IAM + documentation](https://cloud.google.com/iam/help/conditions/resource-policies). + + **JSON example:** + + :literal:`` { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag": "BwWWja0YfJA=", "version": 3 }`\ \` + + **YAML example:** + + :literal:`` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3`\ \` + + For a description of IAM and its features, see the + [IAM + documentation](https://cloud.google.com/iam/docs/). + + """ + # 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 = [resource] + 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." + ) + + # - The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.SetIamPolicyRequest(**request) + elif not request: + request = iam_policy_pb2.SetIamPolicyRequest(resource=resource) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.set_iam_policy + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def test_iam_permissions( + self, + request: Optional[Union[iam_policy_pb2.TestIamPermissionsRequest, dict]] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> iam_policy_pb2.TestIamPermissionsResponse: + r"""Gets your permissions on a resource. Returns an empty + set of permissions if the resource doesn't exist. + + Supported resources are: + + - Reservations + + No Google IAM permissions are required to call this + method. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + from google.iam.v1 import iam_policy_pb2 # type: ignore + + async def sample_test_iam_permissions(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = iam_policy_pb2.TestIamPermissionsRequest( + resource="resource_value", + permissions=['permissions_value1', 'permissions_value2'], + ) + + # Make the request + response = await client.test_iam_permissions(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.iam.v1.iam_policy_pb2.TestIamPermissionsRequest, dict]]): + The request object. Request message for ``TestIamPermissions`` method. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.iam.v1.iam_policy_pb2.TestIamPermissionsResponse: + Response message for TestIamPermissions method. + """ + # Create or coerce a protobuf request object. + # - The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + if isinstance(request, dict): + request = iam_policy_pb2.TestIamPermissionsRequest(**request) + elif not request: + request = iam_policy_pb2.TestIamPermissionsRequest() + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.test_iam_permissions + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def create_reservation_group( + self, + request: Optional[ + Union[reservation.CreateReservationGroupRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.ReservationGroup: + r"""Creates a new reservation group. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + async def sample_create_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.CreateReservationGroupRequest( + parent="parent_value", + reservation_group_id="reservation_group_id_value", + ) + + # Make the request + response = await client.create_reservation_group(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.bigquery_reservation_v1.types.CreateReservationGroupRequest, dict]]): + The request object. The request for + [ReservationService.CreateReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.CreateReservationGroup]. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.bigquery_reservation_v1.types.ReservationGroup: + A reservation group is a container + for reservations. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, reservation.CreateReservationGroupRequest): + request = reservation.CreateReservationGroupRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.create_reservation_group + ] + + # 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_reservation_group( + self, + request: Optional[Union[reservation.GetReservationGroupRequest, 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]]] = (), + ) -> reservation.ReservationGroup: + r"""Returns information about the reservation group. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + async def sample_get_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.GetReservationGroupRequest( + name="name_value", + ) + + # Make the request + response = await client.get_reservation_group(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.bigquery_reservation_v1.types.GetReservationGroupRequest, dict]]): + The request object. The request for + [ReservationService.GetReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.GetReservationGroup]. + name (:class:`str`): + Required. Resource name of the reservation group to + retrieve. E.g., + ``projects/myproject/locations/US/reservationGroups/team1-prod`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.bigquery_reservation_v1.types.ReservationGroup: + A reservation group is a container + for reservations. + + """ + # 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, reservation.GetReservationGroupRequest): + request = reservation.GetReservationGroupRequest(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_reservation_group + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def delete_reservation_group( + self, + request: Optional[ + Union[reservation.DeleteReservationGroupRequest, 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 reservation. Returns + ``google.rpc.Code.FAILED_PRECONDITION`` when reservation has + assignments. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + async def sample_delete_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.DeleteReservationGroupRequest( + name="name_value", + ) + + # Make the request + await client.delete_reservation_group(request=request) + + Args: + request (Optional[Union[google.cloud.bigquery_reservation_v1.types.DeleteReservationGroupRequest, dict]]): + The request object. The request for + [ReservationService.DeleteReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservationGroup]. + name (:class:`str`): + Required. Resource name of the reservation group to + retrieve. E.g., + ``projects/myproject/locations/US/reservationGroups/team1-prod`` + + 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, reservation.DeleteReservationGroupRequest): + request = reservation.DeleteReservationGroupRequest(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_reservation_group + ] + + # 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 list_reservation_groups( + self, + request: Optional[Union[reservation.ListReservationGroupsRequest, 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.ListReservationGroupsAsyncPager: + r"""Lists all the reservation groups for the project in + the specified location. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + async def sample_list_reservation_groups(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.ListReservationGroupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_reservation_groups(request=request) + + # Handle the response + async for response in page_result: + print(response) + + Args: + request (Optional[Union[google.cloud.bigquery_reservation_v1.types.ListReservationGroupsRequest, dict]]): + The request object. The request for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + parent (:class:`str`): + Required. The parent resource name containing project + and location, e.g.: ``projects/myproject/locations/US`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.bigquery_reservation_v1.services.reservation_service.pagers.ListReservationGroupsAsyncPager: + The response for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + + 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, reservation.ListReservationGroupsRequest): + request = reservation.ListReservationGroupsRequest(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_reservation_groups + ] + + # 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.ListReservationGroupsAsyncPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + async def __aenter__(self) -> "ReservationServiceAsyncClient": return self diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/client.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/client.py index f231c2c3bf50..25b4924c96d9 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/client.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/client.py @@ -61,6 +61,8 @@ _LOGGER = std_logging.getLogger(__name__) +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from google.rpc import status_pb2 # type: ignore @@ -307,6 +309,28 @@ def parse_reservation_path(path: str) -> Dict[str, str]: ) return m.groupdict() if m else {} + @staticmethod + def reservation_group_path( + project: str, + location: str, + reservation_group: str, + ) -> str: + """Returns a fully-qualified reservation_group string.""" + return "projects/{project}/locations/{location}/reservationGroups/{reservation_group}".format( + project=project, + location=location, + reservation_group=reservation_group, + ) + + @staticmethod + def parse_reservation_group_path(path: str) -> Dict[str, str]: + """Parses a reservation_group path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/reservationGroups/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + @staticmethod def common_billing_account_path( billing_account: str, @@ -3613,6 +3637,826 @@ def sample_update_bi_reservation(): # Done; return the response. return response + def get_iam_policy( + self, + request: Optional[Union[iam_policy_pb2.GetIamPolicyRequest, dict]] = None, + *, + resource: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Gets the access control policy for a resource. May return: + + - A\ ``NOT_FOUND`` error if the resource doesn't exist or you + don't have the permission to view it. + - An empty policy if the resource exists but doesn't have a set + policy. + + Supported resources are: + + - Reservations + - ReservationAssignments + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.getIamPolicy`` to get + policies on reservations. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + from google.iam.v1 import iam_policy_pb2 # type: ignore + + def sample_get_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = iam_policy_pb2.GetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = client.get_iam_policy(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.iam.v1.iam_policy_pb2.GetIamPolicyRequest, dict]): + The request object. Request message for ``GetIamPolicy`` method. + resource (str): + REQUIRED: The resource for which the + policy is being requested. See the + operation documentation for the + appropriate value for this field. + + This corresponds to the ``resource`` 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.iam.v1.policy_pb2.Policy: + An Identity and Access Management (IAM) policy, which specifies access + controls for Google Cloud resources. + + A Policy is a collection of bindings. A binding binds + one or more members, or principals, to a single role. + Principals can be user accounts, service accounts, + Google groups, and domains (such as G Suite). A role + is a named list of permissions; each role can be an + IAM predefined role or a user-created custom role. + + For some types of Google Cloud resources, a binding + can also specify a condition, which is a logical + expression that allows access to a resource only if + the expression evaluates to true. A condition can add + constraints based on attributes of the request, the + resource, or both. To learn which resources support + conditions in their IAM policies, see the [IAM + documentation](https://cloud.google.com/iam/help/conditions/resource-policies). + + **JSON example:** + + :literal:`` { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag": "BwWWja0YfJA=", "version": 3 }`\ \` + + **YAML example:** + + :literal:`` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3`\ \` + + For a description of IAM and its features, see the + [IAM + documentation](https://cloud.google.com/iam/docs/). + + """ + # 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 = [resource] + 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." + ) + + if isinstance(request, dict): + # - The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + request = iam_policy_pb2.GetIamPolicyRequest(**request) + elif not request: + # Null request, just make one. + request = iam_policy_pb2.GetIamPolicyRequest() + if resource is not None: + request.resource = resource + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.get_iam_policy] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def set_iam_policy( + self, + request: Optional[Union[iam_policy_pb2.SetIamPolicyRequest, dict]] = None, + *, + resource: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> policy_pb2.Policy: + r"""Sets an access control policy for a resource. Replaces any + existing policy. + + Supported resources are: + + - Reservations + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.setIamPolicy`` to set + policies on reservations. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + from google.iam.v1 import iam_policy_pb2 # type: ignore + + def sample_set_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = iam_policy_pb2.SetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = client.set_iam_policy(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.iam.v1.iam_policy_pb2.SetIamPolicyRequest, dict]): + The request object. Request message for ``SetIamPolicy`` method. + resource (str): + REQUIRED: The resource for which the + policy is being specified. See the + operation documentation for the + appropriate value for this field. + + This corresponds to the ``resource`` 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.iam.v1.policy_pb2.Policy: + An Identity and Access Management (IAM) policy, which specifies access + controls for Google Cloud resources. + + A Policy is a collection of bindings. A binding binds + one or more members, or principals, to a single role. + Principals can be user accounts, service accounts, + Google groups, and domains (such as G Suite). A role + is a named list of permissions; each role can be an + IAM predefined role or a user-created custom role. + + For some types of Google Cloud resources, a binding + can also specify a condition, which is a logical + expression that allows access to a resource only if + the expression evaluates to true. A condition can add + constraints based on attributes of the request, the + resource, or both. To learn which resources support + conditions in their IAM policies, see the [IAM + documentation](https://cloud.google.com/iam/help/conditions/resource-policies). + + **JSON example:** + + :literal:`` { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role": "roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" ], "condition": { "title": "expirable access", "description": "Does not grant access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag": "BwWWja0YfJA=", "version": 3 }`\ \` + + **YAML example:** + + :literal:`` bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com role: roles/resourcemanager.organizationAdmin - members: - user:eve@example.com role: roles/resourcemanager.organizationViewer condition: title: expirable access description: Does not grant access after Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3`\ \` + + For a description of IAM and its features, see the + [IAM + documentation](https://cloud.google.com/iam/docs/). + + """ + # 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 = [resource] + 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." + ) + + if isinstance(request, dict): + # - The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + request = iam_policy_pb2.SetIamPolicyRequest(**request) + elif not request: + # Null request, just make one. + request = iam_policy_pb2.SetIamPolicyRequest() + if resource is not None: + request.resource = resource + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.set_iam_policy] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def test_iam_permissions( + self, + request: Optional[Union[iam_policy_pb2.TestIamPermissionsRequest, dict]] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> iam_policy_pb2.TestIamPermissionsResponse: + r"""Gets your permissions on a resource. Returns an empty + set of permissions if the resource doesn't exist. + + Supported resources are: + + - Reservations + + No Google IAM permissions are required to call this + method. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + from google.iam.v1 import iam_policy_pb2 # type: ignore + + def sample_test_iam_permissions(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = iam_policy_pb2.TestIamPermissionsRequest( + resource="resource_value", + permissions=['permissions_value1', 'permissions_value2'], + ) + + # Make the request + response = client.test_iam_permissions(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.iam.v1.iam_policy_pb2.TestIamPermissionsRequest, dict]): + The request object. Request message for ``TestIamPermissions`` method. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.iam.v1.iam_policy_pb2.TestIamPermissionsResponse: + Response message for TestIamPermissions method. + """ + # Create or coerce a protobuf request object. + if isinstance(request, dict): + # - The request isn't a proto-plus wrapped type, + # so it must be constructed via keyword expansion. + request = iam_policy_pb2.TestIamPermissionsRequest(**request) + elif not request: + # Null request, just make one. + request = iam_policy_pb2.TestIamPermissionsRequest() + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.test_iam_permissions] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("resource", request.resource),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def create_reservation_group( + self, + request: Optional[ + Union[reservation.CreateReservationGroupRequest, dict] + ] = None, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.ReservationGroup: + r"""Creates a new reservation group. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + def sample_create_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.CreateReservationGroupRequest( + parent="parent_value", + reservation_group_id="reservation_group_id_value", + ) + + # Make the request + response = client.create_reservation_group(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.bigquery_reservation_v1.types.CreateReservationGroupRequest, dict]): + The request object. The request for + [ReservationService.CreateReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.CreateReservationGroup]. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.bigquery_reservation_v1.types.ReservationGroup: + A reservation group is a container + for reservations. + + """ + # Create or coerce a protobuf request object. + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, reservation.CreateReservationGroupRequest): + request = reservation.CreateReservationGroupRequest(request) + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.create_reservation_group] + + # 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_reservation_group( + self, + request: Optional[Union[reservation.GetReservationGroupRequest, 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]]] = (), + ) -> reservation.ReservationGroup: + r"""Returns information about the reservation group. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + def sample_get_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.GetReservationGroupRequest( + name="name_value", + ) + + # Make the request + response = client.get_reservation_group(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.bigquery_reservation_v1.types.GetReservationGroupRequest, dict]): + The request object. The request for + [ReservationService.GetReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.GetReservationGroup]. + name (str): + Required. Resource name of the reservation group to + retrieve. E.g., + ``projects/myproject/locations/US/reservationGroups/team1-prod`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.bigquery_reservation_v1.types.ReservationGroup: + A reservation group is a container + for reservations. + + """ + # 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, reservation.GetReservationGroupRequest): + request = reservation.GetReservationGroupRequest(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_reservation_group] + + # 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 delete_reservation_group( + self, + request: Optional[ + Union[reservation.DeleteReservationGroupRequest, 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 reservation. Returns + ``google.rpc.Code.FAILED_PRECONDITION`` when reservation has + assignments. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + def sample_delete_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.DeleteReservationGroupRequest( + name="name_value", + ) + + # Make the request + client.delete_reservation_group(request=request) + + Args: + request (Union[google.cloud.bigquery_reservation_v1.types.DeleteReservationGroupRequest, dict]): + The request object. The request for + [ReservationService.DeleteReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservationGroup]. + name (str): + Required. Resource name of the reservation group to + retrieve. E.g., + ``projects/myproject/locations/US/reservationGroups/team1-prod`` + + 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, reservation.DeleteReservationGroupRequest): + request = reservation.DeleteReservationGroupRequest(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_reservation_group] + + # 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 list_reservation_groups( + self, + request: Optional[Union[reservation.ListReservationGroupsRequest, 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.ListReservationGroupsPager: + r"""Lists all the reservation groups for the project in + the specified location. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import bigquery_reservation_v1 + + def sample_list_reservation_groups(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.ListReservationGroupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_reservation_groups(request=request) + + # Handle the response + for response in page_result: + print(response) + + Args: + request (Union[google.cloud.bigquery_reservation_v1.types.ListReservationGroupsRequest, dict]): + The request object. The request for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + parent (str): + Required. The parent resource name containing project + and location, e.g.: ``projects/myproject/locations/US`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.bigquery_reservation_v1.services.reservation_service.pagers.ListReservationGroupsPager: + The response for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + + 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, reservation.ListReservationGroupsRequest): + request = reservation.ListReservationGroupsRequest(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_reservation_groups] + + # 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.ListReservationGroupsPager( + method=rpc, + request=request, + response=response, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + def __enter__(self) -> "ReservationServiceClient": return self diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/pagers.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/pagers.py index aee5c7b808d5..8627ddb401f8 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/pagers.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/pagers.py @@ -819,3 +819,159 @@ async def async_generator(): def __repr__(self) -> str: return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListReservationGroupsPager: + """A pager for iterating through ``list_reservation_groups`` requests. + + This class thinly wraps an initial + :class:`google.cloud.bigquery_reservation_v1.types.ListReservationGroupsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``reservation_groups`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListReservationGroups`` requests and continue to iterate + through the ``reservation_groups`` field on the + corresponding responses. + + All the usual :class:`google.cloud.bigquery_reservation_v1.types.ListReservationGroupsResponse` + 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[..., reservation.ListReservationGroupsResponse], + request: reservation.ListReservationGroupsRequest, + response: reservation.ListReservationGroupsResponse, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.bigquery_reservation_v1.types.ListReservationGroupsRequest): + The initial request object. + response (google.cloud.bigquery_reservation_v1.types.ListReservationGroupsResponse): + 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 = reservation.ListReservationGroupsRequest(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[reservation.ListReservationGroupsResponse]: + 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[reservation.ReservationGroup]: + for page in self.pages: + yield from page.reservation_groups + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListReservationGroupsAsyncPager: + """A pager for iterating through ``list_reservation_groups`` requests. + + This class thinly wraps an initial + :class:`google.cloud.bigquery_reservation_v1.types.ListReservationGroupsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``reservation_groups`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListReservationGroups`` requests and continue to iterate + through the ``reservation_groups`` field on the + corresponding responses. + + All the usual :class:`google.cloud.bigquery_reservation_v1.types.ListReservationGroupsResponse` + 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[reservation.ListReservationGroupsResponse]], + request: reservation.ListReservationGroupsRequest, + response: reservation.ListReservationGroupsResponse, + *, + retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.bigquery_reservation_v1.types.ListReservationGroupsRequest): + The initial request object. + response (google.cloud.bigquery_reservation_v1.types.ListReservationGroupsResponse): + 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 = reservation.ListReservationGroupsRequest(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[reservation.ListReservationGroupsResponse]: + 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[reservation.ReservationGroup]: + async def async_generator(): + async for page in self.pages: + for response in page.reservation_groups: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/base.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/base.py index 87d865fa6372..4149670c19de 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/base.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/base.py @@ -22,6 +22,8 @@ from google.api_core import retry as retries import google.auth # type: ignore from google.auth import credentials as ga_credentials # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.oauth2 import service_account # type: ignore import google.protobuf from google.protobuf import empty_pb2 # type: ignore @@ -347,6 +349,41 @@ def _prep_wrapped_messages(self, client_info): default_timeout=300.0, client_info=client_info, ), + self.get_iam_policy: gapic_v1.method.wrap_method( + self.get_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.set_iam_policy: gapic_v1.method.wrap_method( + self.set_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.test_iam_permissions: gapic_v1.method.wrap_method( + self.test_iam_permissions, + default_timeout=None, + client_info=client_info, + ), + self.create_reservation_group: gapic_v1.method.wrap_method( + self.create_reservation_group, + default_timeout=None, + client_info=client_info, + ), + self.get_reservation_group: gapic_v1.method.wrap_method( + self.get_reservation_group, + default_timeout=None, + client_info=client_info, + ), + self.delete_reservation_group: gapic_v1.method.wrap_method( + self.delete_reservation_group, + default_timeout=None, + client_info=client_info, + ), + self.list_reservation_groups: gapic_v1.method.wrap_method( + self.list_reservation_groups, + default_timeout=None, + client_info=client_info, + ), } def close(self): @@ -582,6 +619,75 @@ def update_bi_reservation( ]: raise NotImplementedError() + @property + def get_iam_policy( + self, + ) -> Callable[ + [iam_policy_pb2.GetIamPolicyRequest], + Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]], + ]: + raise NotImplementedError() + + @property + def set_iam_policy( + self, + ) -> Callable[ + [iam_policy_pb2.SetIamPolicyRequest], + Union[policy_pb2.Policy, Awaitable[policy_pb2.Policy]], + ]: + raise NotImplementedError() + + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + Union[ + iam_policy_pb2.TestIamPermissionsResponse, + Awaitable[iam_policy_pb2.TestIamPermissionsResponse], + ], + ]: + raise NotImplementedError() + + @property + def create_reservation_group( + self, + ) -> Callable[ + [reservation.CreateReservationGroupRequest], + Union[reservation.ReservationGroup, Awaitable[reservation.ReservationGroup]], + ]: + raise NotImplementedError() + + @property + def get_reservation_group( + self, + ) -> Callable[ + [reservation.GetReservationGroupRequest], + Union[reservation.ReservationGroup, Awaitable[reservation.ReservationGroup]], + ]: + raise NotImplementedError() + + @property + def delete_reservation_group( + self, + ) -> Callable[ + [reservation.DeleteReservationGroupRequest], + Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], + ]: + raise NotImplementedError() + + @property + def list_reservation_groups( + self, + ) -> Callable[ + [reservation.ListReservationGroupsRequest], + Union[ + reservation.ListReservationGroupsResponse, + Awaitable[reservation.ListReservationGroupsResponse], + ], + ]: + raise NotImplementedError() + @property def kind(self) -> str: raise NotImplementedError() diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc.py index 901cc5ccbcef..48cefe4365f6 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc.py @@ -23,6 +23,8 @@ import google.auth # type: ignore from google.auth import credentials as ga_credentials # type: ignore from google.auth.transport.grpc import SslCredentials # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore from google.protobuf.json_format import MessageToJson import google.protobuf.message @@ -1111,6 +1113,236 @@ def update_bi_reservation( ) return self._stubs["update_bi_reservation"] + @property + def get_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]: + r"""Return a callable for the get iam policy method over gRPC. + + Gets the access control policy for a resource. May return: + + - A\ ``NOT_FOUND`` error if the resource doesn't exist or you + don't have the permission to view it. + - An empty policy if the resource exists but doesn't have a set + policy. + + Supported resources are: + + - Reservations + - ReservationAssignments + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.getIamPolicy`` to get + policies on reservations. + + Returns: + Callable[[~.GetIamPolicyRequest], + ~.Policy]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_iam_policy" not in self._stubs: + self._stubs["get_iam_policy"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/GetIamPolicy", + request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["get_iam_policy"] + + @property + def set_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]: + r"""Return a callable for the set iam policy method over gRPC. + + Sets an access control policy for a resource. Replaces any + existing policy. + + Supported resources are: + + - Reservations + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.setIamPolicy`` to set + policies on reservations. + + Returns: + Callable[[~.SetIamPolicyRequest], + ~.Policy]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "set_iam_policy" not in self._stubs: + self._stubs["set_iam_policy"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/SetIamPolicy", + request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["set_iam_policy"] + + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + iam_policy_pb2.TestIamPermissionsResponse, + ]: + r"""Return a callable for the test iam permissions method over gRPC. + + Gets your permissions on a resource. Returns an empty + set of permissions if the resource doesn't exist. + + Supported resources are: + + - Reservations + + No Google IAM permissions are required to call this + method. + + Returns: + Callable[[~.TestIamPermissionsRequest], + ~.TestIamPermissionsResponse]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "test_iam_permissions" not in self._stubs: + self._stubs["test_iam_permissions"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/TestIamPermissions", + request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString, + response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString, + ) + return self._stubs["test_iam_permissions"] + + @property + def create_reservation_group( + self, + ) -> Callable[ + [reservation.CreateReservationGroupRequest], reservation.ReservationGroup + ]: + r"""Return a callable for the create reservation group method over gRPC. + + Creates a new reservation group. + + Returns: + Callable[[~.CreateReservationGroupRequest], + ~.ReservationGroup]: + 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_reservation_group" not in self._stubs: + self._stubs["create_reservation_group"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/CreateReservationGroup", + request_serializer=reservation.CreateReservationGroupRequest.serialize, + response_deserializer=reservation.ReservationGroup.deserialize, + ) + return self._stubs["create_reservation_group"] + + @property + def get_reservation_group( + self, + ) -> Callable[ + [reservation.GetReservationGroupRequest], reservation.ReservationGroup + ]: + r"""Return a callable for the get reservation group method over gRPC. + + Returns information about the reservation group. + + Returns: + Callable[[~.GetReservationGroupRequest], + ~.ReservationGroup]: + 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_reservation_group" not in self._stubs: + self._stubs["get_reservation_group"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/GetReservationGroup", + request_serializer=reservation.GetReservationGroupRequest.serialize, + response_deserializer=reservation.ReservationGroup.deserialize, + ) + return self._stubs["get_reservation_group"] + + @property + def delete_reservation_group( + self, + ) -> Callable[[reservation.DeleteReservationGroupRequest], empty_pb2.Empty]: + r"""Return a callable for the delete reservation group method over gRPC. + + Deletes a reservation. Returns + ``google.rpc.Code.FAILED_PRECONDITION`` when reservation has + assignments. + + Returns: + Callable[[~.DeleteReservationGroupRequest], + ~.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_reservation_group" not in self._stubs: + self._stubs["delete_reservation_group"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteReservationGroup", + request_serializer=reservation.DeleteReservationGroupRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_reservation_group"] + + @property + def list_reservation_groups( + self, + ) -> Callable[ + [reservation.ListReservationGroupsRequest], + reservation.ListReservationGroupsResponse, + ]: + r"""Return a callable for the list reservation groups method over gRPC. + + Lists all the reservation groups for the project in + the specified location. + + Returns: + Callable[[~.ListReservationGroupsRequest], + ~.ListReservationGroupsResponse]: + 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_reservation_groups" not in self._stubs: + self._stubs["list_reservation_groups"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/ListReservationGroups", + request_serializer=reservation.ListReservationGroupsRequest.serialize, + response_deserializer=reservation.ListReservationGroupsResponse.deserialize, + ) + return self._stubs["list_reservation_groups"] + def close(self): self._logged_channel.close() diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc_asyncio.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc_asyncio.py index f779e288e885..adfda3b912d0 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc_asyncio.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/grpc_asyncio.py @@ -25,6 +25,8 @@ from google.api_core import retry_async as retries from google.auth import credentials as ga_credentials # type: ignore from google.auth.transport.grpc import SslCredentials # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore from google.protobuf.json_format import MessageToJson import google.protobuf.message @@ -1144,6 +1146,240 @@ def update_bi_reservation( ) return self._stubs["update_bi_reservation"] + @property + def get_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], Awaitable[policy_pb2.Policy]]: + r"""Return a callable for the get iam policy method over gRPC. + + Gets the access control policy for a resource. May return: + + - A\ ``NOT_FOUND`` error if the resource doesn't exist or you + don't have the permission to view it. + - An empty policy if the resource exists but doesn't have a set + policy. + + Supported resources are: + + - Reservations + - ReservationAssignments + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.getIamPolicy`` to get + policies on reservations. + + Returns: + Callable[[~.GetIamPolicyRequest], + Awaitable[~.Policy]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "get_iam_policy" not in self._stubs: + self._stubs["get_iam_policy"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/GetIamPolicy", + request_serializer=iam_policy_pb2.GetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["get_iam_policy"] + + @property + def set_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], Awaitable[policy_pb2.Policy]]: + r"""Return a callable for the set iam policy method over gRPC. + + Sets an access control policy for a resource. Replaces any + existing policy. + + Supported resources are: + + - Reservations + + To call this method, you must have the following Google IAM + permissions: + + - ``bigqueryreservation.reservations.setIamPolicy`` to set + policies on reservations. + + Returns: + Callable[[~.SetIamPolicyRequest], + Awaitable[~.Policy]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "set_iam_policy" not in self._stubs: + self._stubs["set_iam_policy"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/SetIamPolicy", + request_serializer=iam_policy_pb2.SetIamPolicyRequest.SerializeToString, + response_deserializer=policy_pb2.Policy.FromString, + ) + return self._stubs["set_iam_policy"] + + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + Awaitable[iam_policy_pb2.TestIamPermissionsResponse], + ]: + r"""Return a callable for the test iam permissions method over gRPC. + + Gets your permissions on a resource. Returns an empty + set of permissions if the resource doesn't exist. + + Supported resources are: + + - Reservations + + No Google IAM permissions are required to call this + method. + + Returns: + Callable[[~.TestIamPermissionsRequest], + Awaitable[~.TestIamPermissionsResponse]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "test_iam_permissions" not in self._stubs: + self._stubs["test_iam_permissions"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/TestIamPermissions", + request_serializer=iam_policy_pb2.TestIamPermissionsRequest.SerializeToString, + response_deserializer=iam_policy_pb2.TestIamPermissionsResponse.FromString, + ) + return self._stubs["test_iam_permissions"] + + @property + def create_reservation_group( + self, + ) -> Callable[ + [reservation.CreateReservationGroupRequest], + Awaitable[reservation.ReservationGroup], + ]: + r"""Return a callable for the create reservation group method over gRPC. + + Creates a new reservation group. + + Returns: + Callable[[~.CreateReservationGroupRequest], + Awaitable[~.ReservationGroup]]: + 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_reservation_group" not in self._stubs: + self._stubs["create_reservation_group"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/CreateReservationGroup", + request_serializer=reservation.CreateReservationGroupRequest.serialize, + response_deserializer=reservation.ReservationGroup.deserialize, + ) + return self._stubs["create_reservation_group"] + + @property + def get_reservation_group( + self, + ) -> Callable[ + [reservation.GetReservationGroupRequest], + Awaitable[reservation.ReservationGroup], + ]: + r"""Return a callable for the get reservation group method over gRPC. + + Returns information about the reservation group. + + Returns: + Callable[[~.GetReservationGroupRequest], + Awaitable[~.ReservationGroup]]: + 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_reservation_group" not in self._stubs: + self._stubs["get_reservation_group"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/GetReservationGroup", + request_serializer=reservation.GetReservationGroupRequest.serialize, + response_deserializer=reservation.ReservationGroup.deserialize, + ) + return self._stubs["get_reservation_group"] + + @property + def delete_reservation_group( + self, + ) -> Callable[ + [reservation.DeleteReservationGroupRequest], Awaitable[empty_pb2.Empty] + ]: + r"""Return a callable for the delete reservation group method over gRPC. + + Deletes a reservation. Returns + ``google.rpc.Code.FAILED_PRECONDITION`` when reservation has + assignments. + + Returns: + Callable[[~.DeleteReservationGroupRequest], + 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_reservation_group" not in self._stubs: + self._stubs["delete_reservation_group"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteReservationGroup", + request_serializer=reservation.DeleteReservationGroupRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_reservation_group"] + + @property + def list_reservation_groups( + self, + ) -> Callable[ + [reservation.ListReservationGroupsRequest], + Awaitable[reservation.ListReservationGroupsResponse], + ]: + r"""Return a callable for the list reservation groups method over gRPC. + + Lists all the reservation groups for the project in + the specified location. + + Returns: + Callable[[~.ListReservationGroupsRequest], + Awaitable[~.ListReservationGroupsResponse]]: + 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_reservation_groups" not in self._stubs: + self._stubs["list_reservation_groups"] = self._logged_channel.unary_unary( + "/google.cloud.bigquery.reservation.v1.ReservationService/ListReservationGroups", + request_serializer=reservation.ListReservationGroupsRequest.serialize, + response_deserializer=reservation.ListReservationGroupsResponse.deserialize, + ) + return self._stubs["list_reservation_groups"] + def _prep_wrapped_messages(self, client_info): """Precompute the wrapped methods, overriding the base class method to use async wrappers.""" self._wrapped_methods = { @@ -1357,6 +1593,41 @@ def _prep_wrapped_messages(self, client_info): default_timeout=300.0, client_info=client_info, ), + self.get_iam_policy: self._wrap_method( + self.get_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.set_iam_policy: self._wrap_method( + self.set_iam_policy, + default_timeout=None, + client_info=client_info, + ), + self.test_iam_permissions: self._wrap_method( + self.test_iam_permissions, + default_timeout=None, + client_info=client_info, + ), + self.create_reservation_group: self._wrap_method( + self.create_reservation_group, + default_timeout=None, + client_info=client_info, + ), + self.get_reservation_group: self._wrap_method( + self.get_reservation_group, + default_timeout=None, + client_info=client_info, + ), + self.delete_reservation_group: self._wrap_method( + self.delete_reservation_group, + default_timeout=None, + client_info=client_info, + ), + self.list_reservation_groups: self._wrap_method( + self.list_reservation_groups, + default_timeout=None, + client_info=client_info, + ), } def _wrap_method(self, func, *args, **kwargs): diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest.py index 132d7126b60e..3a17ba8ef4b7 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest.py @@ -24,6 +24,8 @@ from google.api_core import retry as retries from google.auth import credentials as ga_credentials # type: ignore from google.auth.transport.requests import AuthorizedSession # type: ignore +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore import google.protobuf from google.protobuf import empty_pb2 # type: ignore from google.protobuf import json_format @@ -98,6 +100,14 @@ def post_create_reservation(self, response): logging.log(f"Received response: {response}") return response + def pre_create_reservation_group(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_reservation_group(self, response): + logging.log(f"Received response: {response}") + return response + def pre_delete_assignment(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -110,6 +120,10 @@ def pre_delete_reservation(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata + def pre_delete_reservation_group(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + def pre_failover_reservation(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -134,6 +148,14 @@ def post_get_capacity_commitment(self, response): logging.log(f"Received response: {response}") return response + def pre_get_iam_policy(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_iam_policy(self, response): + logging.log(f"Received response: {response}") + return response + def pre_get_reservation(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -142,6 +164,14 @@ def post_get_reservation(self, response): logging.log(f"Received response: {response}") return response + def pre_get_reservation_group(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_reservation_group(self, response): + logging.log(f"Received response: {response}") + return response + def pre_list_assignments(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -158,6 +188,14 @@ def post_list_capacity_commitments(self, response): logging.log(f"Received response: {response}") return response + def pre_list_reservation_groups(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_reservation_groups(self, response): + logging.log(f"Received response: {response}") + return response + def pre_list_reservations(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -198,6 +236,14 @@ def post_search_assignments(self, response): logging.log(f"Received response: {response}") return response + def pre_set_iam_policy(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_set_iam_policy(self, response): + logging.log(f"Received response: {response}") + return response + def pre_split_capacity_commitment(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -206,6 +252,14 @@ def post_split_capacity_commitment(self, response): logging.log(f"Received response: {response}") return response + def pre_test_iam_permissions(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_test_iam_permissions(self, response): + logging.log(f"Received response: {response}") + return response + def pre_update_assignment(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -390,6 +444,55 @@ def post_create_reservation_with_metadata( """ return response, metadata + def pre_create_reservation_group( + self, + request: reservation.CreateReservationGroupRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + reservation.CreateReservationGroupRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for create_reservation_group + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + + def post_create_reservation_group( + self, response: reservation.ReservationGroup + ) -> reservation.ReservationGroup: + """Post-rpc interceptor for create_reservation_group + + DEPRECATED. Please use the `post_create_reservation_group_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the ReservationService server but before + it is returned to user code. This `post_create_reservation_group` interceptor runs + before the `post_create_reservation_group_with_metadata` interceptor. + """ + return response + + def post_create_reservation_group_with_metadata( + self, + response: reservation.ReservationGroup, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[reservation.ReservationGroup, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for create_reservation_group + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the ReservationService server but before it is returned to user code. + + We recommend only using this `post_create_reservation_group_with_metadata` + interceptor in new development instead of the `post_create_reservation_group` interceptor. + When both interceptors are used, this `post_create_reservation_group_with_metadata` interceptor runs after the + `post_create_reservation_group` interceptor. The (possibly modified) response returned by + `post_create_reservation_group` will be passed to + `post_create_reservation_group_with_metadata`. + """ + return response, metadata + def pre_delete_assignment( self, request: reservation.DeleteAssignmentRequest, @@ -433,6 +536,21 @@ def pre_delete_reservation( """ return request, metadata + def pre_delete_reservation_group( + self, + request: reservation.DeleteReservationGroupRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + reservation.DeleteReservationGroupRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for delete_reservation_group + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + def pre_failover_reservation( self, request: reservation.FailoverReservationRequest, @@ -578,6 +696,52 @@ def post_get_capacity_commitment_with_metadata( """ return response, metadata + def pre_get_iam_policy( + self, + request: iam_policy_pb2.GetIamPolicyRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.GetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_iam_policy + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + + def post_get_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy: + """Post-rpc interceptor for get_iam_policy + + DEPRECATED. Please use the `post_get_iam_policy_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the ReservationService server but before + it is returned to user code. This `post_get_iam_policy` interceptor runs + before the `post_get_iam_policy_with_metadata` interceptor. + """ + return response + + def post_get_iam_policy_with_metadata( + self, + response: policy_pb2.Policy, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[policy_pb2.Policy, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for get_iam_policy + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the ReservationService server but before it is returned to user code. + + We recommend only using this `post_get_iam_policy_with_metadata` + interceptor in new development instead of the `post_get_iam_policy` interceptor. + When both interceptors are used, this `post_get_iam_policy_with_metadata` interceptor runs after the + `post_get_iam_policy` interceptor. The (possibly modified) response returned by + `post_get_iam_policy` will be passed to + `post_get_iam_policy_with_metadata`. + """ + return response, metadata + def pre_get_reservation( self, request: reservation.GetReservationRequest, @@ -626,6 +790,54 @@ def post_get_reservation_with_metadata( """ return response, metadata + def pre_get_reservation_group( + self, + request: reservation.GetReservationGroupRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + reservation.GetReservationGroupRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_reservation_group + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + + def post_get_reservation_group( + self, response: reservation.ReservationGroup + ) -> reservation.ReservationGroup: + """Post-rpc interceptor for get_reservation_group + + DEPRECATED. Please use the `post_get_reservation_group_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the ReservationService server but before + it is returned to user code. This `post_get_reservation_group` interceptor runs + before the `post_get_reservation_group_with_metadata` interceptor. + """ + return response + + def post_get_reservation_group_with_metadata( + self, + response: reservation.ReservationGroup, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[reservation.ReservationGroup, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for get_reservation_group + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the ReservationService server but before it is returned to user code. + + We recommend only using this `post_get_reservation_group_with_metadata` + interceptor in new development instead of the `post_get_reservation_group` interceptor. + When both interceptors are used, this `post_get_reservation_group_with_metadata` interceptor runs after the + `post_get_reservation_group` interceptor. The (possibly modified) response returned by + `post_get_reservation_group` will be passed to + `post_get_reservation_group_with_metadata`. + """ + return response, metadata + def pre_list_assignments( self, request: reservation.ListAssignmentsRequest, @@ -728,6 +940,58 @@ def post_list_capacity_commitments_with_metadata( """ return response, metadata + def pre_list_reservation_groups( + self, + request: reservation.ListReservationGroupsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + reservation.ListReservationGroupsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for list_reservation_groups + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + + def post_list_reservation_groups( + self, response: reservation.ListReservationGroupsResponse + ) -> reservation.ListReservationGroupsResponse: + """Post-rpc interceptor for list_reservation_groups + + DEPRECATED. Please use the `post_list_reservation_groups_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the ReservationService server but before + it is returned to user code. This `post_list_reservation_groups` interceptor runs + before the `post_list_reservation_groups_with_metadata` interceptor. + """ + return response + + def post_list_reservation_groups_with_metadata( + self, + response: reservation.ListReservationGroupsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + reservation.ListReservationGroupsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for list_reservation_groups + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the ReservationService server but before it is returned to user code. + + We recommend only using this `post_list_reservation_groups_with_metadata` + interceptor in new development instead of the `post_list_reservation_groups` interceptor. + When both interceptors are used, this `post_list_reservation_groups_with_metadata` interceptor runs after the + `post_list_reservation_groups` interceptor. The (possibly modified) response returned by + `post_list_reservation_groups` will be passed to + `post_list_reservation_groups_with_metadata`. + """ + return response, metadata + def pre_list_reservations( self, request: reservation.ListReservationsRequest, @@ -976,6 +1240,52 @@ def post_search_assignments_with_metadata( """ return response, metadata + def pre_set_iam_policy( + self, + request: iam_policy_pb2.SetIamPolicyRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.SetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for set_iam_policy + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + + def post_set_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy: + """Post-rpc interceptor for set_iam_policy + + DEPRECATED. Please use the `post_set_iam_policy_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the ReservationService server but before + it is returned to user code. This `post_set_iam_policy` interceptor runs + before the `post_set_iam_policy_with_metadata` interceptor. + """ + return response + + def post_set_iam_policy_with_metadata( + self, + response: policy_pb2.Policy, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[policy_pb2.Policy, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for set_iam_policy + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the ReservationService server but before it is returned to user code. + + We recommend only using this `post_set_iam_policy_with_metadata` + interceptor in new development instead of the `post_set_iam_policy` interceptor. + When both interceptors are used, this `post_set_iam_policy_with_metadata` interceptor runs after the + `post_set_iam_policy` interceptor. The (possibly modified) response returned by + `post_set_iam_policy` will be passed to + `post_set_iam_policy_with_metadata`. + """ + return response, metadata + def pre_split_capacity_commitment( self, request: reservation.SplitCapacityCommitmentRequest, @@ -1028,6 +1338,58 @@ def post_split_capacity_commitment_with_metadata( """ return response, metadata + def pre_test_iam_permissions( + self, + request: iam_policy_pb2.TestIamPermissionsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.TestIamPermissionsRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for test_iam_permissions + + Override in a subclass to manipulate the request or metadata + before they are sent to the ReservationService server. + """ + return request, metadata + + def post_test_iam_permissions( + self, response: iam_policy_pb2.TestIamPermissionsResponse + ) -> iam_policy_pb2.TestIamPermissionsResponse: + """Post-rpc interceptor for test_iam_permissions + + DEPRECATED. Please use the `post_test_iam_permissions_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the ReservationService server but before + it is returned to user code. This `post_test_iam_permissions` interceptor runs + before the `post_test_iam_permissions_with_metadata` interceptor. + """ + return response + + def post_test_iam_permissions_with_metadata( + self, + response: iam_policy_pb2.TestIamPermissionsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + iam_policy_pb2.TestIamPermissionsResponse, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Post-rpc interceptor for test_iam_permissions + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the ReservationService server but before it is returned to user code. + + We recommend only using this `post_test_iam_permissions_with_metadata` + interceptor in new development instead of the `post_test_iam_permissions` interceptor. + When both interceptors are used, this `post_test_iam_permissions_with_metadata` interceptor runs after the + `post_test_iam_permissions` interceptor. The (possibly modified) response returned by + `post_test_iam_permissions` will be passed to + `post_test_iam_permissions_with_metadata`. + """ + return response, metadata + def pre_update_assignment( self, request: reservation.UpdateAssignmentRequest, @@ -1810,12 +2172,12 @@ def __call__( ) return resp - class _DeleteAssignment( - _BaseReservationServiceRestTransport._BaseDeleteAssignment, + class _CreateReservationGroup( + _BaseReservationServiceRestTransport._BaseCreateReservationGroup, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.DeleteAssignment") + return hash("ReservationServiceRestTransport.CreateReservationGroup") @staticmethod def _get_response( @@ -1836,25 +2198,24 @@ def _get_response( timeout=timeout, headers=headers, params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, ) return response def __call__( self, - request: reservation.DeleteAssignmentRequest, + request: reservation.CreateReservationGroupRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ): - r"""Call the delete assignment method over HTTP. + ) -> reservation.ReservationGroup: + r"""Call the create reservation group method over HTTP. Args: - request (~.reservation.DeleteAssignmentRequest): + request (~.reservation.CreateReservationGroupRequest): The request object. The request for - [ReservationService.DeleteAssignment][google.cloud.bigquery.reservation.v1.ReservationService.DeleteAssignment]. - Note: "bigquery.reservationAssignments.delete" - permission is required on the related assignee. + [ReservationService.CreateReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.CreateReservationGroup]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -1862,21 +2223,31 @@ def __call__( 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: + ~.reservation.ReservationGroup: + A reservation group is a container + for reservations. + """ http_options = ( - _BaseReservationServiceRestTransport._BaseDeleteAssignment._get_http_options() + _BaseReservationServiceRestTransport._BaseCreateReservationGroup._get_http_options() ) - request, metadata = self._interceptor.pre_delete_assignment( + request, metadata = self._interceptor.pre_create_reservation_group( request, metadata ) - transcoded_request = _BaseReservationServiceRestTransport._BaseDeleteAssignment._get_transcoded_request( + transcoded_request = _BaseReservationServiceRestTransport._BaseCreateReservationGroup._get_transcoded_request( http_options, request ) + body = _BaseReservationServiceRestTransport._BaseCreateReservationGroup._get_request_body_json( + transcoded_request + ) + # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseDeleteAssignment._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseCreateReservationGroup._get_query_params_json( transcoded_request ) @@ -1888,7 +2259,7 @@ def __call__( ) method = transcoded_request["method"] try: - request_payload = json_format.MessageToJson(request) + request_payload = type(request).to_json(request) except: request_payload = None http_request = { @@ -1898,26 +2269,175 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.DeleteAssignment", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.CreateReservationGroup", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "DeleteAssignment", + "rpcName": "CreateReservationGroup", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ReservationServiceRestTransport._DeleteAssignment._get_response( - self._host, - metadata, - query_params, - self._session, - timeout, - transcoded_request, - ) - - # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + response = ( + ReservationServiceRestTransport._CreateReservationGroup._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 = reservation.ReservationGroup() + pb_resp = reservation.ReservationGroup.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_create_reservation_group(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_create_reservation_group_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = reservation.ReservationGroup.to_json(response) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.create_reservation_group", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "CreateReservationGroup", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _DeleteAssignment( + _BaseReservationServiceRestTransport._BaseDeleteAssignment, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.DeleteAssignment") + + @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: reservation.DeleteAssignmentRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ): + r"""Call the delete assignment method over HTTP. + + Args: + request (~.reservation.DeleteAssignmentRequest): + The request object. The request for + [ReservationService.DeleteAssignment][google.cloud.bigquery.reservation.v1.ReservationService.DeleteAssignment]. + Note: "bigquery.reservationAssignments.delete" + permission is required on the related assignee. + 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 = ( + _BaseReservationServiceRestTransport._BaseDeleteAssignment._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_assignment( + request, metadata + ) + transcoded_request = _BaseReservationServiceRestTransport._BaseDeleteAssignment._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseDeleteAssignment._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.DeleteAssignment", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "DeleteAssignment", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ReservationServiceRestTransport._DeleteAssignment._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) @@ -2145,6 +2665,118 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) + class _DeleteReservationGroup( + _BaseReservationServiceRestTransport._BaseDeleteReservationGroup, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.DeleteReservationGroup") + + @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: reservation.DeleteReservationGroupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ): + r"""Call the delete reservation group method over HTTP. + + Args: + request (~.reservation.DeleteReservationGroupRequest): + The request object. The request for + [ReservationService.DeleteReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservationGroup]. + 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 = ( + _BaseReservationServiceRestTransport._BaseDeleteReservationGroup._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_reservation_group( + request, metadata + ) + transcoded_request = _BaseReservationServiceRestTransport._BaseDeleteReservationGroup._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseDeleteReservationGroup._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = json_format.MessageToJson(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.DeleteReservationGroup", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "DeleteReservationGroup", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + ReservationServiceRestTransport._DeleteReservationGroup._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 _FailoverReservation( _BaseReservationServiceRestTransport._BaseFailoverReservation, ReservationServiceRestStub, @@ -2615,12 +3247,12 @@ def __call__( ) return resp - class _GetReservation( - _BaseReservationServiceRestTransport._BaseGetReservation, + class _GetIamPolicy( + _BaseReservationServiceRestTransport._BaseGetIamPolicy, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.GetReservation") + return hash("ReservationServiceRestTransport.GetIamPolicy") @staticmethod def _get_response( @@ -2646,18 +3278,17 @@ def _get_response( def __call__( self, - request: reservation.GetReservationRequest, + request: iam_policy_pb2.GetIamPolicyRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.Reservation: - r"""Call the get reservation method over HTTP. + ) -> policy_pb2.Policy: + r"""Call the get iam policy method over HTTP. Args: - request (~.reservation.GetReservationRequest): - The request object. The request for - [ReservationService.GetReservation][google.cloud.bigquery.reservation.v1.ReservationService.GetReservation]. + request (~.iam_policy_pb2.GetIamPolicyRequest): + The request object. Request message for ``GetIamPolicy`` method. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -2667,23 +3298,96 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.Reservation: - A reservation is a mechanism used to - guarantee slots to users. + ~.policy_pb2.Policy: + An Identity and Access Management (IAM) policy, which + specifies access controls for Google Cloud resources. + + A ``Policy`` is a collection of ``bindings``. A + ``binding`` binds one or more ``members``, or + principals, to a single ``role``. Principals can be user + accounts, service accounts, Google groups, and domains + (such as G Suite). A ``role`` is a named list of + permissions; each ``role`` can be an IAM predefined role + or a user-created custom role. + + For some types of Google Cloud resources, a ``binding`` + can also specify a ``condition``, which is a logical + expression that allows access to a resource only if the + expression evaluates to ``true``. A condition can add + constraints based on attributes of the request, the + resource, or both. To learn which resources support + conditions in their IAM policies, see the `IAM + documentation `__. + + **JSON example:** + + :: + + { + "bindings": [ + { + "role": "roles/resourcemanager.organizationAdmin", + "members": [ + "user:mike@example.com", + "group:admins@example.com", + "domain:google.com", + "serviceAccount:my-project-id@appspot.gserviceaccount.com" + ] + }, + { + "role": "roles/resourcemanager.organizationViewer", + "members": [ + "user:eve@example.com" + ], + "condition": { + "title": "expirable access", + "description": "Does not grant access after Sep 2020", + "expression": "request.time < + timestamp('2020-10-01T00:00:00.000Z')", + } + } + ], + "etag": "BwWWja0YfJA=", + "version": 3 + } + + **YAML example:** + + :: + + bindings: + - members: + - user:mike@example.com + - group:admins@example.com + - domain:google.com + - serviceAccount:my-project-id@appspot.gserviceaccount.com + role: roles/resourcemanager.organizationAdmin + - members: + - user:eve@example.com + role: roles/resourcemanager.organizationViewer + condition: + title: expirable access + description: Does not grant access after Sep 2020 + expression: request.time < timestamp('2020-10-01T00:00:00.000Z') + etag: BwWWja0YfJA= + version: 3 + + For a description of IAM and its features, see the `IAM + documentation `__. """ http_options = ( - _BaseReservationServiceRestTransport._BaseGetReservation._get_http_options() + _BaseReservationServiceRestTransport._BaseGetIamPolicy._get_http_options() ) - request, metadata = self._interceptor.pre_get_reservation(request, metadata) - transcoded_request = _BaseReservationServiceRestTransport._BaseGetReservation._get_transcoded_request( + request, metadata = self._interceptor.pre_get_iam_policy(request, metadata) + transcoded_request = _BaseReservationServiceRestTransport._BaseGetIamPolicy._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseGetReservation._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseGetIamPolicy._get_query_params_json( transcoded_request ) @@ -2695,7 +3399,7 @@ def __call__( ) method = transcoded_request["method"] try: - request_payload = type(request).to_json(request) + request_payload = json_format.MessageToJson(request) except: request_payload = None http_request = { @@ -2705,17 +3409,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.GetReservation", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.GetIamPolicy", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "GetReservation", + "rpcName": "GetIamPolicy", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ReservationServiceRestTransport._GetReservation._get_response( + response = ReservationServiceRestTransport._GetIamPolicy._get_response( self._host, metadata, query_params, @@ -2730,21 +3434,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.Reservation() - pb_resp = reservation.Reservation.pb(resp) + resp = policy_pb2.Policy() + pb_resp = resp json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_reservation(resp) + resp = self._interceptor.post_get_iam_policy(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_reservation_with_metadata( + resp, _ = self._interceptor.post_get_iam_policy_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.Reservation.to_json(response) + response_payload = json_format.MessageToJson(resp) except: response_payload = None http_response = { @@ -2753,22 +3457,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.get_reservation", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.get_iam_policy", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "GetReservation", + "rpcName": "GetIamPolicy", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListAssignments( - _BaseReservationServiceRestTransport._BaseListAssignments, + class _GetReservation( + _BaseReservationServiceRestTransport._BaseGetReservation, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.ListAssignments") + return hash("ReservationServiceRestTransport.GetReservation") @staticmethod def _get_response( @@ -2794,18 +3498,18 @@ def _get_response( def __call__( self, - request: reservation.ListAssignmentsRequest, + request: reservation.GetReservationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.ListAssignmentsResponse: - r"""Call the list assignments method over HTTP. + ) -> reservation.Reservation: + r"""Call the get reservation method over HTTP. Args: - request (~.reservation.ListAssignmentsRequest): + request (~.reservation.GetReservationRequest): The request object. The request for - [ReservationService.ListAssignments][google.cloud.bigquery.reservation.v1.ReservationService.ListAssignments]. + [ReservationService.GetReservation][google.cloud.bigquery.reservation.v1.ReservationService.GetReservation]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -2815,25 +3519,23 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.ListAssignmentsResponse: - The response for - [ReservationService.ListAssignments][google.cloud.bigquery.reservation.v1.ReservationService.ListAssignments]. + ~.reservation.Reservation: + A reservation is a mechanism used to + guarantee slots to users. """ http_options = ( - _BaseReservationServiceRestTransport._BaseListAssignments._get_http_options() + _BaseReservationServiceRestTransport._BaseGetReservation._get_http_options() ) - request, metadata = self._interceptor.pre_list_assignments( - request, metadata - ) - transcoded_request = _BaseReservationServiceRestTransport._BaseListAssignments._get_transcoded_request( + request, metadata = self._interceptor.pre_get_reservation(request, metadata) + transcoded_request = _BaseReservationServiceRestTransport._BaseGetReservation._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseListAssignments._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseGetReservation._get_query_params_json( transcoded_request ) @@ -2855,17 +3557,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListAssignments", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.GetReservation", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "ListAssignments", + "rpcName": "GetReservation", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ReservationServiceRestTransport._ListAssignments._get_response( + response = ReservationServiceRestTransport._GetReservation._get_response( self._host, metadata, query_params, @@ -2880,23 +3582,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.ListAssignmentsResponse() - pb_resp = reservation.ListAssignmentsResponse.pb(resp) + resp = reservation.Reservation() + pb_resp = reservation.Reservation.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_assignments(resp) + resp = self._interceptor.post_get_reservation(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_assignments_with_metadata( + resp, _ = self._interceptor.post_get_reservation_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.ListAssignmentsResponse.to_json( - response - ) + response_payload = reservation.Reservation.to_json(response) except: response_payload = None http_response = { @@ -2905,22 +3605,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_assignments", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.get_reservation", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "ListAssignments", + "rpcName": "GetReservation", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListCapacityCommitments( - _BaseReservationServiceRestTransport._BaseListCapacityCommitments, + class _GetReservationGroup( + _BaseReservationServiceRestTransport._BaseGetReservationGroup, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.ListCapacityCommitments") + return hash("ReservationServiceRestTransport.GetReservationGroup") @staticmethod def _get_response( @@ -2946,18 +3646,18 @@ def _get_response( def __call__( self, - request: reservation.ListCapacityCommitmentsRequest, + request: reservation.GetReservationGroupRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.ListCapacityCommitmentsResponse: - r"""Call the list capacity commitments method over HTTP. + ) -> reservation.ReservationGroup: + r"""Call the get reservation group method over HTTP. Args: - request (~.reservation.ListCapacityCommitmentsRequest): + request (~.reservation.GetReservationGroupRequest): The request object. The request for - [ReservationService.ListCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.ListCapacityCommitments]. + [ReservationService.GetReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.GetReservationGroup]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -2967,25 +3667,25 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.ListCapacityCommitmentsResponse: - The response for - [ReservationService.ListCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.ListCapacityCommitments]. + ~.reservation.ReservationGroup: + A reservation group is a container + for reservations. """ http_options = ( - _BaseReservationServiceRestTransport._BaseListCapacityCommitments._get_http_options() + _BaseReservationServiceRestTransport._BaseGetReservationGroup._get_http_options() ) - request, metadata = self._interceptor.pre_list_capacity_commitments( + request, metadata = self._interceptor.pre_get_reservation_group( request, metadata ) - transcoded_request = _BaseReservationServiceRestTransport._BaseListCapacityCommitments._get_transcoded_request( + transcoded_request = _BaseReservationServiceRestTransport._BaseGetReservationGroup._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseListCapacityCommitments._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseGetReservationGroup._get_query_params_json( transcoded_request ) @@ -3007,10 +3707,10 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListCapacityCommitments", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.GetReservationGroup", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "ListCapacityCommitments", + "rpcName": "GetReservationGroup", "httpRequest": http_request, "metadata": http_request["headers"], }, @@ -3018,7 +3718,7 @@ def __call__( # Send the request response = ( - ReservationServiceRestTransport._ListCapacityCommitments._get_response( + ReservationServiceRestTransport._GetReservationGroup._get_response( self._host, metadata, query_params, @@ -3034,23 +3734,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.ListCapacityCommitmentsResponse() - pb_resp = reservation.ListCapacityCommitmentsResponse.pb(resp) + resp = reservation.ReservationGroup() + pb_resp = reservation.ReservationGroup.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_capacity_commitments(resp) + resp = self._interceptor.post_get_reservation_group(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_capacity_commitments_with_metadata( + resp, _ = self._interceptor.post_get_reservation_group_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = ( - reservation.ListCapacityCommitmentsResponse.to_json(response) - ) + response_payload = reservation.ReservationGroup.to_json(response) except: response_payload = None http_response = { @@ -3059,22 +3757,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_capacity_commitments", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.get_reservation_group", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "ListCapacityCommitments", + "rpcName": "GetReservationGroup", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListReservations( - _BaseReservationServiceRestTransport._BaseListReservations, + class _ListAssignments( + _BaseReservationServiceRestTransport._BaseListAssignments, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.ListReservations") + return hash("ReservationServiceRestTransport.ListAssignments") @staticmethod def _get_response( @@ -3100,18 +3798,18 @@ def _get_response( def __call__( self, - request: reservation.ListReservationsRequest, + request: reservation.ListAssignmentsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.ListReservationsResponse: - r"""Call the list reservations method over HTTP. + ) -> reservation.ListAssignmentsResponse: + r"""Call the list assignments method over HTTP. Args: - request (~.reservation.ListReservationsRequest): + request (~.reservation.ListAssignmentsRequest): The request object. The request for - [ReservationService.ListReservations][google.cloud.bigquery.reservation.v1.ReservationService.ListReservations]. + [ReservationService.ListAssignments][google.cloud.bigquery.reservation.v1.ReservationService.ListAssignments]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3121,25 +3819,25 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.ListReservationsResponse: + ~.reservation.ListAssignmentsResponse: The response for - [ReservationService.ListReservations][google.cloud.bigquery.reservation.v1.ReservationService.ListReservations]. + [ReservationService.ListAssignments][google.cloud.bigquery.reservation.v1.ReservationService.ListAssignments]. """ http_options = ( - _BaseReservationServiceRestTransport._BaseListReservations._get_http_options() + _BaseReservationServiceRestTransport._BaseListAssignments._get_http_options() ) - request, metadata = self._interceptor.pre_list_reservations( + request, metadata = self._interceptor.pre_list_assignments( request, metadata ) - transcoded_request = _BaseReservationServiceRestTransport._BaseListReservations._get_transcoded_request( + transcoded_request = _BaseReservationServiceRestTransport._BaseListAssignments._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseListReservations._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseListAssignments._get_query_params_json( transcoded_request ) @@ -3161,17 +3859,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListReservations", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListAssignments", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "ListReservations", + "rpcName": "ListAssignments", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ReservationServiceRestTransport._ListReservations._get_response( + response = ReservationServiceRestTransport._ListAssignments._get_response( self._host, metadata, query_params, @@ -3186,21 +3884,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.ListReservationsResponse() - pb_resp = reservation.ListReservationsResponse.pb(resp) + resp = reservation.ListAssignmentsResponse() + pb_resp = reservation.ListAssignmentsResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_reservations(resp) + resp = self._interceptor.post_list_assignments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_reservations_with_metadata( + resp, _ = self._interceptor.post_list_assignments_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.ListReservationsResponse.to_json( + response_payload = reservation.ListAssignmentsResponse.to_json( response ) except: @@ -3211,22 +3909,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_reservations", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_assignments", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "ListReservations", + "rpcName": "ListAssignments", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _MergeCapacityCommitments( - _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments, + class _ListCapacityCommitments( + _BaseReservationServiceRestTransport._BaseListCapacityCommitments, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.MergeCapacityCommitments") + return hash("ReservationServiceRestTransport.ListCapacityCommitments") @staticmethod def _get_response( @@ -3247,69 +3945,51 @@ def _get_response( timeout=timeout, headers=headers, params=rest_helpers.flatten_query_params(query_params, strict=True), - data=body, ) return response def __call__( self, - request: reservation.MergeCapacityCommitmentsRequest, + request: reservation.ListCapacityCommitmentsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.CapacityCommitment: - r"""Call the merge capacity - commitments method over HTTP. - - Args: - request (~.reservation.MergeCapacityCommitmentsRequest): - The request object. The request for - [ReservationService.MergeCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.MergeCapacityCommitments]. - 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: - ~.reservation.CapacityCommitment: - Capacity commitment is a way to - purchase compute capacity for BigQuery - jobs (in the form of slots) with some - committed period of usage. Annual - commitments renew by default. - Commitments can be removed after their - commitment end time passes. + ) -> reservation.ListCapacityCommitmentsResponse: + r"""Call the list capacity commitments method over HTTP. - In order to remove annual commitment, - its plan needs to be changed to monthly - or flex first. + Args: + request (~.reservation.ListCapacityCommitmentsRequest): + The request object. The request for + [ReservationService.ListCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.ListCapacityCommitments]. + 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`. - A capacity commitment resource exists as - a child resource of the admin project. + Returns: + ~.reservation.ListCapacityCommitmentsResponse: + The response for + [ReservationService.ListCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.ListCapacityCommitments]. """ http_options = ( - _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_http_options() + _BaseReservationServiceRestTransport._BaseListCapacityCommitments._get_http_options() ) - request, metadata = self._interceptor.pre_merge_capacity_commitments( + request, metadata = self._interceptor.pre_list_capacity_commitments( request, metadata ) - transcoded_request = _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_transcoded_request( + transcoded_request = _BaseReservationServiceRestTransport._BaseListCapacityCommitments._get_transcoded_request( http_options, request ) - body = _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_request_body_json( - transcoded_request - ) - # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseListCapacityCommitments._get_query_params_json( transcoded_request ) @@ -3331,10 +4011,10 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.MergeCapacityCommitments", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListCapacityCommitments", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "MergeCapacityCommitments", + "rpcName": "ListCapacityCommitments", "httpRequest": http_request, "metadata": http_request["headers"], }, @@ -3342,14 +4022,13 @@ def __call__( # Send the request response = ( - ReservationServiceRestTransport._MergeCapacityCommitments._get_response( + ReservationServiceRestTransport._ListCapacityCommitments._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, - body, ) ) @@ -3359,21 +4038,23 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.CapacityCommitment() - pb_resp = reservation.CapacityCommitment.pb(resp) + resp = reservation.ListCapacityCommitmentsResponse() + pb_resp = reservation.ListCapacityCommitmentsResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_merge_capacity_commitments(resp) + resp = self._interceptor.post_list_capacity_commitments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_merge_capacity_commitments_with_metadata( + resp, _ = self._interceptor.post_list_capacity_commitments_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.CapacityCommitment.to_json(response) + response_payload = ( + reservation.ListCapacityCommitmentsResponse.to_json(response) + ) except: response_payload = None http_response = { @@ -3382,22 +4063,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.merge_capacity_commitments", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_capacity_commitments", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "MergeCapacityCommitments", + "rpcName": "ListCapacityCommitments", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _MoveAssignment( - _BaseReservationServiceRestTransport._BaseMoveAssignment, + class _ListReservationGroups( + _BaseReservationServiceRestTransport._BaseListReservationGroups, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.MoveAssignment") + return hash("ReservationServiceRestTransport.ListReservationGroups") @staticmethod def _get_response( @@ -3418,31 +4099,820 @@ def _get_response( timeout=timeout, headers=headers, params=rest_helpers.flatten_query_params(query_params, strict=True), - data=body, ) return response def __call__( self, - request: reservation.MoveAssignmentRequest, + request: reservation.ListReservationGroupsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.Assignment: - r"""Call the move assignment method over HTTP. + ) -> reservation.ListReservationGroupsResponse: + r"""Call the list reservation groups method over HTTP. Args: - request (~.reservation.MoveAssignmentRequest): + request (~.reservation.ListReservationGroupsRequest): The request object. The request for - [ReservationService.MoveAssignment][google.cloud.bigquery.reservation.v1.ReservationService.MoveAssignment]. - - **Note**: "bigquery.reservationAssignments.create" - permission is required on the destination_id. + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + 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: + ~.reservation.ListReservationGroupsResponse: + The response for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + + """ + + http_options = ( + _BaseReservationServiceRestTransport._BaseListReservationGroups._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_reservation_groups( + request, metadata + ) + transcoded_request = _BaseReservationServiceRestTransport._BaseListReservationGroups._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseListReservationGroups._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListReservationGroups", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "ListReservationGroups", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + ReservationServiceRestTransport._ListReservationGroups._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 = reservation.ListReservationGroupsResponse() + pb_resp = reservation.ListReservationGroupsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_reservation_groups(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_list_reservation_groups_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = ( + reservation.ListReservationGroupsResponse.to_json(response) + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_reservation_groups", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "ListReservationGroups", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ListReservations( + _BaseReservationServiceRestTransport._BaseListReservations, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.ListReservations") + + @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: reservation.ListReservationsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.ListReservationsResponse: + r"""Call the list reservations method over HTTP. + + Args: + request (~.reservation.ListReservationsRequest): + The request object. The request for + [ReservationService.ListReservations][google.cloud.bigquery.reservation.v1.ReservationService.ListReservations]. + 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: + ~.reservation.ListReservationsResponse: + The response for + [ReservationService.ListReservations][google.cloud.bigquery.reservation.v1.ReservationService.ListReservations]. + + """ + + http_options = ( + _BaseReservationServiceRestTransport._BaseListReservations._get_http_options() + ) + + request, metadata = self._interceptor.pre_list_reservations( + request, metadata + ) + transcoded_request = _BaseReservationServiceRestTransport._BaseListReservations._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseListReservations._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.ListReservations", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "ListReservations", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ReservationServiceRestTransport._ListReservations._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 = reservation.ListReservationsResponse() + pb_resp = reservation.ListReservationsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_reservations(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_list_reservations_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = reservation.ListReservationsResponse.to_json( + response + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.list_reservations", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "ListReservations", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _MergeCapacityCommitments( + _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.MergeCapacityCommitments") + + @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: reservation.MergeCapacityCommitmentsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.CapacityCommitment: + r"""Call the merge capacity + commitments method over HTTP. + + Args: + request (~.reservation.MergeCapacityCommitmentsRequest): + The request object. The request for + [ReservationService.MergeCapacityCommitments][google.cloud.bigquery.reservation.v1.ReservationService.MergeCapacityCommitments]. + 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: + ~.reservation.CapacityCommitment: + Capacity commitment is a way to + purchase compute capacity for BigQuery + jobs (in the form of slots) with some + committed period of usage. Annual + commitments renew by default. + Commitments can be removed after their + commitment end time passes. + + In order to remove annual commitment, + its plan needs to be changed to monthly + or flex first. + + A capacity commitment resource exists as + a child resource of the admin project. + + """ + + http_options = ( + _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_http_options() + ) + + request, metadata = self._interceptor.pre_merge_capacity_commitments( + request, metadata + ) + transcoded_request = _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_transcoded_request( + http_options, request + ) + + body = _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseMergeCapacityCommitments._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.MergeCapacityCommitments", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "MergeCapacityCommitments", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + ReservationServiceRestTransport._MergeCapacityCommitments._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 = reservation.CapacityCommitment() + pb_resp = reservation.CapacityCommitment.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_merge_capacity_commitments(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_merge_capacity_commitments_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = reservation.CapacityCommitment.to_json(response) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.merge_capacity_commitments", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "MergeCapacityCommitments", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _MoveAssignment( + _BaseReservationServiceRestTransport._BaseMoveAssignment, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.MoveAssignment") + + @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: reservation.MoveAssignmentRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.Assignment: + r"""Call the move assignment method over HTTP. + + Args: + request (~.reservation.MoveAssignmentRequest): + The request object. The request for + [ReservationService.MoveAssignment][google.cloud.bigquery.reservation.v1.ReservationService.MoveAssignment]. + + **Note**: "bigquery.reservationAssignments.create" + permission is required on the destination_id. + + **Note**: "bigquery.reservationAssignments.create" and + "bigquery.reservationAssignments.delete" permission are + required on the related assignee. + 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: + ~.reservation.Assignment: + An assignment allows a project to + submit jobs of a certain type using + slots from the specified reservation. + + """ + + http_options = ( + _BaseReservationServiceRestTransport._BaseMoveAssignment._get_http_options() + ) + + request, metadata = self._interceptor.pre_move_assignment(request, metadata) + transcoded_request = _BaseReservationServiceRestTransport._BaseMoveAssignment._get_transcoded_request( + http_options, request + ) + + body = _BaseReservationServiceRestTransport._BaseMoveAssignment._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseMoveAssignment._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.MoveAssignment", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "MoveAssignment", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ReservationServiceRestTransport._MoveAssignment._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 = reservation.Assignment() + pb_resp = reservation.Assignment.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_move_assignment(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_move_assignment_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = reservation.Assignment.to_json(response) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.move_assignment", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "MoveAssignment", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _SearchAllAssignments( + _BaseReservationServiceRestTransport._BaseSearchAllAssignments, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.SearchAllAssignments") + + @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: reservation.SearchAllAssignmentsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.SearchAllAssignmentsResponse: + r"""Call the search all assignments method over HTTP. + + Args: + request (~.reservation.SearchAllAssignmentsRequest): + The request object. The request for + [ReservationService.SearchAllAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAllAssignments]. + Note: "bigquery.reservationAssignments.search" + permission is required on the related assignee. + 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: + ~.reservation.SearchAllAssignmentsResponse: + The response for + [ReservationService.SearchAllAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAllAssignments]. + + """ + + http_options = ( + _BaseReservationServiceRestTransport._BaseSearchAllAssignments._get_http_options() + ) + + request, metadata = self._interceptor.pre_search_all_assignments( + request, metadata + ) + transcoded_request = _BaseReservationServiceRestTransport._BaseSearchAllAssignments._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseReservationServiceRestTransport._BaseSearchAllAssignments._get_query_params_json( + transcoded_request + ) + + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + request_url = "{host}{uri}".format( + host=self._host, uri=transcoded_request["uri"] + ) + method = transcoded_request["method"] + try: + request_payload = type(request).to_json(request) + except: + request_payload = None + http_request = { + "payload": request_payload, + "requestMethod": method, + "requestUrl": request_url, + "headers": dict(metadata), + } + _LOGGER.debug( + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SearchAllAssignments", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "SearchAllAssignments", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + ReservationServiceRestTransport._SearchAllAssignments._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 = reservation.SearchAllAssignmentsResponse() + pb_resp = reservation.SearchAllAssignmentsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_search_all_assignments(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_search_all_assignments_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = reservation.SearchAllAssignmentsResponse.to_json( + response + ) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.search_all_assignments", + extra={ + "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", + "rpcName": "SearchAllAssignments", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _SearchAssignments( + _BaseReservationServiceRestTransport._BaseSearchAssignments, + ReservationServiceRestStub, + ): + def __hash__(self): + return hash("ReservationServiceRestTransport.SearchAssignments") + + @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: reservation.SearchAssignmentsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> reservation.SearchAssignmentsResponse: + r"""Call the search assignments method over HTTP. - **Note**: "bigquery.reservationAssignments.create" and - "bigquery.reservationAssignments.delete" permission are - required on the related assignee. + Args: + request (~.reservation.SearchAssignmentsRequest): + The request object. The request for + [ReservationService.SearchAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAssignments]. + Note: "bigquery.reservationAssignments.search" + permission is required on the related assignee. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3452,28 +4922,25 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.Assignment: - An assignment allows a project to - submit jobs of a certain type using - slots from the specified reservation. + ~.reservation.SearchAssignmentsResponse: + The response for + [ReservationService.SearchAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAssignments]. """ http_options = ( - _BaseReservationServiceRestTransport._BaseMoveAssignment._get_http_options() + _BaseReservationServiceRestTransport._BaseSearchAssignments._get_http_options() ) - request, metadata = self._interceptor.pre_move_assignment(request, metadata) - transcoded_request = _BaseReservationServiceRestTransport._BaseMoveAssignment._get_transcoded_request( - http_options, request + request, metadata = self._interceptor.pre_search_assignments( + request, metadata ) - - body = _BaseReservationServiceRestTransport._BaseMoveAssignment._get_request_body_json( - transcoded_request + transcoded_request = _BaseReservationServiceRestTransport._BaseSearchAssignments._get_transcoded_request( + http_options, request ) # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseMoveAssignment._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseSearchAssignments._get_query_params_json( transcoded_request ) @@ -3495,24 +4962,23 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.MoveAssignment", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SearchAssignments", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "MoveAssignment", + "rpcName": "SearchAssignments", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ReservationServiceRestTransport._MoveAssignment._get_response( + response = ReservationServiceRestTransport._SearchAssignments._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, - body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -3521,21 +4987,23 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.Assignment() - pb_resp = reservation.Assignment.pb(resp) + resp = reservation.SearchAssignmentsResponse() + pb_resp = reservation.SearchAssignmentsResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_move_assignment(resp) + resp = self._interceptor.post_search_assignments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_move_assignment_with_metadata( + resp, _ = self._interceptor.post_search_assignments_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.Assignment.to_json(response) + response_payload = reservation.SearchAssignmentsResponse.to_json( + response + ) except: response_payload = None http_response = { @@ -3544,22 +5012,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.move_assignment", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.search_assignments", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "MoveAssignment", + "rpcName": "SearchAssignments", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _SearchAllAssignments( - _BaseReservationServiceRestTransport._BaseSearchAllAssignments, + class _SetIamPolicy( + _BaseReservationServiceRestTransport._BaseSetIamPolicy, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.SearchAllAssignments") + return hash("ReservationServiceRestTransport.SetIamPolicy") @staticmethod def _get_response( @@ -3580,25 +5048,23 @@ def _get_response( timeout=timeout, headers=headers, params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, ) return response def __call__( self, - request: reservation.SearchAllAssignmentsRequest, + request: iam_policy_pb2.SetIamPolicyRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.SearchAllAssignmentsResponse: - r"""Call the search all assignments method over HTTP. + ) -> policy_pb2.Policy: + r"""Call the set iam policy method over HTTP. Args: - request (~.reservation.SearchAllAssignmentsRequest): - The request object. The request for - [ReservationService.SearchAllAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAllAssignments]. - Note: "bigquery.reservationAssignments.search" - permission is required on the related assignee. + request (~.iam_policy_pb2.SetIamPolicyRequest): + The request object. Request message for ``SetIamPolicy`` method. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3608,25 +5074,100 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.SearchAllAssignmentsResponse: - The response for - [ReservationService.SearchAllAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAllAssignments]. + ~.policy_pb2.Policy: + An Identity and Access Management (IAM) policy, which + specifies access controls for Google Cloud resources. + + A ``Policy`` is a collection of ``bindings``. A + ``binding`` binds one or more ``members``, or + principals, to a single ``role``. Principals can be user + accounts, service accounts, Google groups, and domains + (such as G Suite). A ``role`` is a named list of + permissions; each ``role`` can be an IAM predefined role + or a user-created custom role. + + For some types of Google Cloud resources, a ``binding`` + can also specify a ``condition``, which is a logical + expression that allows access to a resource only if the + expression evaluates to ``true``. A condition can add + constraints based on attributes of the request, the + resource, or both. To learn which resources support + conditions in their IAM policies, see the `IAM + documentation `__. + + **JSON example:** + + :: + + { + "bindings": [ + { + "role": "roles/resourcemanager.organizationAdmin", + "members": [ + "user:mike@example.com", + "group:admins@example.com", + "domain:google.com", + "serviceAccount:my-project-id@appspot.gserviceaccount.com" + ] + }, + { + "role": "roles/resourcemanager.organizationViewer", + "members": [ + "user:eve@example.com" + ], + "condition": { + "title": "expirable access", + "description": "Does not grant access after Sep 2020", + "expression": "request.time < + timestamp('2020-10-01T00:00:00.000Z')", + } + } + ], + "etag": "BwWWja0YfJA=", + "version": 3 + } + + **YAML example:** + + :: + + bindings: + - members: + - user:mike@example.com + - group:admins@example.com + - domain:google.com + - serviceAccount:my-project-id@appspot.gserviceaccount.com + role: roles/resourcemanager.organizationAdmin + - members: + - user:eve@example.com + role: roles/resourcemanager.organizationViewer + condition: + title: expirable access + description: Does not grant access after Sep 2020 + expression: request.time < timestamp('2020-10-01T00:00:00.000Z') + etag: BwWWja0YfJA= + version: 3 + + For a description of IAM and its features, see the `IAM + documentation `__. """ http_options = ( - _BaseReservationServiceRestTransport._BaseSearchAllAssignments._get_http_options() + _BaseReservationServiceRestTransport._BaseSetIamPolicy._get_http_options() ) - request, metadata = self._interceptor.pre_search_all_assignments( - request, metadata - ) - transcoded_request = _BaseReservationServiceRestTransport._BaseSearchAllAssignments._get_transcoded_request( + request, metadata = self._interceptor.pre_set_iam_policy(request, metadata) + transcoded_request = _BaseReservationServiceRestTransport._BaseSetIamPolicy._get_transcoded_request( http_options, request ) + body = _BaseReservationServiceRestTransport._BaseSetIamPolicy._get_request_body_json( + transcoded_request + ) + # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseSearchAllAssignments._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseSetIamPolicy._get_query_params_json( transcoded_request ) @@ -3638,7 +5179,7 @@ def __call__( ) method = transcoded_request["method"] try: - request_payload = type(request).to_json(request) + request_payload = json_format.MessageToJson(request) except: request_payload = None http_request = { @@ -3648,25 +5189,24 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SearchAllAssignments", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SetIamPolicy", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "SearchAllAssignments", + "rpcName": "SetIamPolicy", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ( - ReservationServiceRestTransport._SearchAllAssignments._get_response( - self._host, - metadata, - query_params, - self._session, - timeout, - transcoded_request, - ) + response = ReservationServiceRestTransport._SetIamPolicy._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -3675,23 +5215,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.SearchAllAssignmentsResponse() - pb_resp = reservation.SearchAllAssignmentsResponse.pb(resp) + resp = policy_pb2.Policy() + pb_resp = resp json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_search_all_assignments(resp) + resp = self._interceptor.post_set_iam_policy(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_search_all_assignments_with_metadata( + resp, _ = self._interceptor.post_set_iam_policy_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.SearchAllAssignmentsResponse.to_json( - response - ) + response_payload = json_format.MessageToJson(resp) except: response_payload = None http_response = { @@ -3700,22 +5238,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.search_all_assignments", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.set_iam_policy", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "SearchAllAssignments", + "rpcName": "SetIamPolicy", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _SearchAssignments( - _BaseReservationServiceRestTransport._BaseSearchAssignments, + class _SplitCapacityCommitment( + _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.SearchAssignments") + return hash("ReservationServiceRestTransport.SplitCapacityCommitment") @staticmethod def _get_response( @@ -3736,25 +5274,24 @@ def _get_response( timeout=timeout, headers=headers, params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, ) return response def __call__( self, - request: reservation.SearchAssignmentsRequest, + request: reservation.SplitCapacityCommitmentRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.SearchAssignmentsResponse: - r"""Call the search assignments method over HTTP. + ) -> reservation.SplitCapacityCommitmentResponse: + r"""Call the split capacity commitment method over HTTP. Args: - request (~.reservation.SearchAssignmentsRequest): + request (~.reservation.SplitCapacityCommitmentRequest): The request object. The request for - [ReservationService.SearchAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAssignments]. - Note: "bigquery.reservationAssignments.search" - permission is required on the related assignee. + [ReservationService.SplitCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.SplitCapacityCommitment]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3764,25 +5301,29 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.SearchAssignmentsResponse: + ~.reservation.SplitCapacityCommitmentResponse: The response for - [ReservationService.SearchAssignments][google.cloud.bigquery.reservation.v1.ReservationService.SearchAssignments]. + [ReservationService.SplitCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.SplitCapacityCommitment]. """ http_options = ( - _BaseReservationServiceRestTransport._BaseSearchAssignments._get_http_options() + _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_http_options() ) - request, metadata = self._interceptor.pre_search_assignments( + request, metadata = self._interceptor.pre_split_capacity_commitment( request, metadata ) - transcoded_request = _BaseReservationServiceRestTransport._BaseSearchAssignments._get_transcoded_request( + transcoded_request = _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_transcoded_request( http_options, request ) + body = _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_request_body_json( + transcoded_request + ) + # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseSearchAssignments._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_query_params_json( transcoded_request ) @@ -3804,23 +5345,26 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SearchAssignments", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SplitCapacityCommitment", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "SearchAssignments", + "rpcName": "SplitCapacityCommitment", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = ReservationServiceRestTransport._SearchAssignments._get_response( - self._host, - metadata, - query_params, - self._session, - timeout, - transcoded_request, + response = ( + ReservationServiceRestTransport._SplitCapacityCommitment._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -3829,22 +5373,22 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.SearchAssignmentsResponse() - pb_resp = reservation.SearchAssignmentsResponse.pb(resp) + resp = reservation.SplitCapacityCommitmentResponse() + pb_resp = reservation.SplitCapacityCommitmentResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_search_assignments(resp) + resp = self._interceptor.post_split_capacity_commitment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_search_assignments_with_metadata( + resp, _ = self._interceptor.post_split_capacity_commitment_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = reservation.SearchAssignmentsResponse.to_json( - response + response_payload = ( + reservation.SplitCapacityCommitmentResponse.to_json(response) ) except: response_payload = None @@ -3854,22 +5398,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.search_assignments", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.split_capacity_commitment", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "SearchAssignments", + "rpcName": "SplitCapacityCommitment", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _SplitCapacityCommitment( - _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment, + class _TestIamPermissions( + _BaseReservationServiceRestTransport._BaseTestIamPermissions, ReservationServiceRestStub, ): def __hash__(self): - return hash("ReservationServiceRestTransport.SplitCapacityCommitment") + return hash("ReservationServiceRestTransport.TestIamPermissions") @staticmethod def _get_response( @@ -3896,18 +5440,17 @@ def _get_response( def __call__( self, - request: reservation.SplitCapacityCommitmentRequest, + request: iam_policy_pb2.TestIamPermissionsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> reservation.SplitCapacityCommitmentResponse: - r"""Call the split capacity commitment method over HTTP. + ) -> iam_policy_pb2.TestIamPermissionsResponse: + r"""Call the test iam permissions method over HTTP. Args: - request (~.reservation.SplitCapacityCommitmentRequest): - The request object. The request for - [ReservationService.SplitCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.SplitCapacityCommitment]. + request (~.iam_policy_pb2.TestIamPermissionsRequest): + The request object. Request message for ``TestIamPermissions`` method. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3917,29 +5460,27 @@ def __call__( be of type `bytes`. Returns: - ~.reservation.SplitCapacityCommitmentResponse: - The response for - [ReservationService.SplitCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.SplitCapacityCommitment]. - + ~.iam_policy_pb2.TestIamPermissionsResponse: + Response message for ``TestIamPermissions`` method. """ http_options = ( - _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_http_options() + _BaseReservationServiceRestTransport._BaseTestIamPermissions._get_http_options() ) - request, metadata = self._interceptor.pre_split_capacity_commitment( + request, metadata = self._interceptor.pre_test_iam_permissions( request, metadata ) - transcoded_request = _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_transcoded_request( + transcoded_request = _BaseReservationServiceRestTransport._BaseTestIamPermissions._get_transcoded_request( http_options, request ) - body = _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_request_body_json( + body = _BaseReservationServiceRestTransport._BaseTestIamPermissions._get_request_body_json( transcoded_request ) # Jsonify the query params - query_params = _BaseReservationServiceRestTransport._BaseSplitCapacityCommitment._get_query_params_json( + query_params = _BaseReservationServiceRestTransport._BaseTestIamPermissions._get_query_params_json( transcoded_request ) @@ -3951,7 +5492,7 @@ def __call__( ) method = transcoded_request["method"] try: - request_payload = type(request).to_json(request) + request_payload = json_format.MessageToJson(request) except: request_payload = None http_request = { @@ -3961,10 +5502,10 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.SplitCapacityCommitment", + f"Sending request for google.cloud.bigquery.reservation_v1.ReservationServiceClient.TestIamPermissions", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "SplitCapacityCommitment", + "rpcName": "TestIamPermissions", "httpRequest": http_request, "metadata": http_request["headers"], }, @@ -3972,7 +5513,7 @@ def __call__( # Send the request response = ( - ReservationServiceRestTransport._SplitCapacityCommitment._get_response( + ReservationServiceRestTransport._TestIamPermissions._get_response( self._host, metadata, query_params, @@ -3989,23 +5530,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = reservation.SplitCapacityCommitmentResponse() - pb_resp = reservation.SplitCapacityCommitmentResponse.pb(resp) + resp = iam_policy_pb2.TestIamPermissionsResponse() + pb_resp = resp json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_split_capacity_commitment(resp) + resp = self._interceptor.post_test_iam_permissions(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_split_capacity_commitment_with_metadata( + resp, _ = self._interceptor.post_test_iam_permissions_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = ( - reservation.SplitCapacityCommitmentResponse.to_json(response) - ) + response_payload = json_format.MessageToJson(resp) except: response_payload = None http_response = { @@ -4014,10 +5553,10 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.split_capacity_commitment", + "Received response for google.cloud.bigquery.reservation_v1.ReservationServiceClient.test_iam_permissions", extra={ "serviceName": "google.cloud.bigquery.reservation.v1.ReservationService", - "rpcName": "SplitCapacityCommitment", + "rpcName": "TestIamPermissions", "metadata": http_response["headers"], "httpResponse": http_response, }, @@ -4691,6 +6230,16 @@ def create_reservation( # In C++ this would require a dynamic_cast return self._CreateReservation(self._session, self._host, self._interceptor) # type: ignore + @property + def create_reservation_group( + self, + ) -> Callable[ + [reservation.CreateReservationGroupRequest], reservation.ReservationGroup + ]: + # 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._CreateReservationGroup(self._session, self._host, self._interceptor) # type: ignore + @property def delete_assignment( self, @@ -4715,6 +6264,14 @@ def delete_reservation( # In C++ this would require a dynamic_cast return self._DeleteReservation(self._session, self._host, self._interceptor) # type: ignore + @property + def delete_reservation_group( + self, + ) -> Callable[[reservation.DeleteReservationGroupRequest], 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._DeleteReservationGroup(self._session, self._host, self._interceptor) # type: ignore + @property def failover_reservation( self, @@ -4741,6 +6298,14 @@ def get_capacity_commitment( # In C++ this would require a dynamic_cast return self._GetCapacityCommitment(self._session, self._host, self._interceptor) # type: ignore + @property + def get_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]: + # 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._GetIamPolicy(self._session, self._host, self._interceptor) # type: ignore + @property def get_reservation( self, @@ -4749,6 +6314,16 @@ def get_reservation( # In C++ this would require a dynamic_cast return self._GetReservation(self._session, self._host, self._interceptor) # type: ignore + @property + def get_reservation_group( + self, + ) -> Callable[ + [reservation.GetReservationGroupRequest], reservation.ReservationGroup + ]: + # 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._GetReservationGroup(self._session, self._host, self._interceptor) # type: ignore + @property def list_assignments( self, @@ -4770,6 +6345,17 @@ def list_capacity_commitments( # In C++ this would require a dynamic_cast return self._ListCapacityCommitments(self._session, self._host, self._interceptor) # type: ignore + @property + def list_reservation_groups( + self, + ) -> Callable[ + [reservation.ListReservationGroupsRequest], + reservation.ListReservationGroupsResponse, + ]: + # 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._ListReservationGroups(self._session, self._host, self._interceptor) # type: ignore + @property def list_reservations( self, @@ -4819,6 +6405,14 @@ def search_assignments( # In C++ this would require a dynamic_cast return self._SearchAssignments(self._session, self._host, self._interceptor) # type: ignore + @property + def set_iam_policy( + self, + ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]: + # 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._SetIamPolicy(self._session, self._host, self._interceptor) # type: ignore + @property def split_capacity_commitment( self, @@ -4830,6 +6424,17 @@ def split_capacity_commitment( # In C++ this would require a dynamic_cast return self._SplitCapacityCommitment(self._session, self._host, self._interceptor) # type: ignore + @property + def test_iam_permissions( + self, + ) -> Callable[ + [iam_policy_pb2.TestIamPermissionsRequest], + iam_policy_pb2.TestIamPermissionsResponse, + ]: + # 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._TestIamPermissions(self._session, self._host, self._interceptor) # type: ignore + @property def update_assignment( self, diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest_base.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest_base.py index 2975a9f9f769..05dc1f45f992 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest_base.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/services/reservation_service/transports/rest_base.py @@ -18,6 +18,8 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union from google.api_core import gapic_v1, path_template +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore from google.protobuf import json_format @@ -260,6 +262,65 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseCreateReservationGroup: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "reservationGroupId": "", + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{parent=projects/*/locations/*}/reservationGroups", + "body": "reservation_group", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = reservation.CreateReservationGroupRequest.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( + _BaseReservationServiceRestTransport._BaseCreateReservationGroup._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseDeleteAssignment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -401,6 +462,53 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseDeleteReservationGroup: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/*/reservationGroups/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = reservation.DeleteReservationGroupRequest.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( + _BaseReservationServiceRestTransport._BaseDeleteReservationGroup._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseFailoverReservation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -552,6 +660,57 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseGetIamPolicy: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{resource=projects/*/locations/*/reservations/*}:getIamPolicy", + }, + { + "method": "get", + "uri": "/v1/{resource=projects/*/locations/*/reservations/*/assignments/*}:getIamPolicy", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = 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( + _BaseReservationServiceRestTransport._BaseGetIamPolicy._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseGetReservation: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -599,6 +758,53 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseGetReservationGroup: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/reservationGroups/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = reservation.GetReservationGroupRequest.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( + _BaseReservationServiceRestTransport._BaseGetReservationGroup._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseListAssignments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -693,6 +899,53 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseListReservationGroups: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/reservationGroups", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = reservation.ListReservationGroupsRequest.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( + _BaseReservationServiceRestTransport._BaseListReservationGroups._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseListReservations: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -933,6 +1186,68 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseSetIamPolicy: + 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": "/v1/{resource=projects/*/locations/*/reservations/*}:setIamPolicy", + "body": "*", + }, + { + "method": "post", + "uri": "/v1/{resource=projects/*/locations/*/reservations/*/assignments/*}:setIamPolicy", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = 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( + _BaseReservationServiceRestTransport._BaseSetIamPolicy._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseSplitCapacityCommitment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -990,6 +1305,68 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseTestIamPermissions: + 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": "/v1/{resource=projects/*/locations/*/reservations/*}:testIamPermissions", + "body": "*", + }, + { + "method": "post", + "uri": "/v1/{resource=projects/*/locations/*/reservations/*/assignments/*}:testIamPermissions", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = 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( + _BaseReservationServiceRestTransport._BaseTestIamPermissions._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseUpdateAssignment: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/__init__.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/__init__.py index 74bde8d86142..5b351a4b3896 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/__init__.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/__init__.py @@ -19,25 +19,32 @@ CapacityCommitment, CreateAssignmentRequest, CreateCapacityCommitmentRequest, + CreateReservationGroupRequest, CreateReservationRequest, DeleteAssignmentRequest, DeleteCapacityCommitmentRequest, + DeleteReservationGroupRequest, DeleteReservationRequest, Edition, FailoverMode, FailoverReservationRequest, GetBiReservationRequest, GetCapacityCommitmentRequest, + GetReservationGroupRequest, GetReservationRequest, ListAssignmentsRequest, ListAssignmentsResponse, ListCapacityCommitmentsRequest, ListCapacityCommitmentsResponse, + ListReservationGroupsRequest, + ListReservationGroupsResponse, ListReservationsRequest, ListReservationsResponse, MergeCapacityCommitmentsRequest, MoveAssignmentRequest, Reservation, + ReservationGroup, + SchedulingPolicy, SearchAllAssignmentsRequest, SearchAllAssignmentsResponse, SearchAssignmentsRequest, @@ -57,23 +64,30 @@ "CapacityCommitment", "CreateAssignmentRequest", "CreateCapacityCommitmentRequest", + "CreateReservationGroupRequest", "CreateReservationRequest", "DeleteAssignmentRequest", "DeleteCapacityCommitmentRequest", + "DeleteReservationGroupRequest", "DeleteReservationRequest", "FailoverReservationRequest", "GetBiReservationRequest", "GetCapacityCommitmentRequest", + "GetReservationGroupRequest", "GetReservationRequest", "ListAssignmentsRequest", "ListAssignmentsResponse", "ListCapacityCommitmentsRequest", "ListCapacityCommitmentsResponse", + "ListReservationGroupsRequest", + "ListReservationGroupsResponse", "ListReservationsRequest", "ListReservationsResponse", "MergeCapacityCommitmentsRequest", "MoveAssignmentRequest", "Reservation", + "ReservationGroup", + "SchedulingPolicy", "SearchAllAssignmentsRequest", "SearchAllAssignmentsResponse", "SearchAssignmentsRequest", diff --git a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/reservation.py b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/reservation.py index ffe1ad24e092..96d5cd21d988 100644 --- a/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/reservation.py +++ b/packages/google-cloud-bigquery-reservation/google/cloud/bigquery_reservation_v1/types/reservation.py @@ -28,6 +28,8 @@ "Edition", "FailoverMode", "Reservation", + "SchedulingPolicy", + "ReservationGroup", "CapacityCommitment", "CreateReservationRequest", "ListReservationsRequest", @@ -36,6 +38,11 @@ "DeleteReservationRequest", "UpdateReservationRequest", "FailoverReservationRequest", + "CreateReservationGroupRequest", + "GetReservationGroupRequest", + "ListReservationGroupsRequest", + "ListReservationGroupsResponse", + "DeleteReservationGroupRequest", "CreateCapacityCommitmentRequest", "ListCapacityCommitmentsRequest", "ListCapacityCommitmentsResponse", @@ -89,7 +96,7 @@ class Edition(proto.Enum): class FailoverMode(proto.Enum): r"""The failover mode when a user initiates a failover on a - reservation determines how writes that arepending replication + reservation determines how writes that are pending replication are handled after the failover is initiated. Values: @@ -121,15 +128,15 @@ class Reservation(proto.Message): Attributes: name (str): - The resource name of the reservation, e.g., + Identifier. The resource name of the reservation, e.g., ``projects/*/locations/*/reservations/team1-prod``. The reservation_id must only contain lower case alphanumeric characters or dashes. It must start with a letter and must not end with a dash. Its maximum length is 64 characters. slot_capacity (int): - Baseline slots available to this reservation. A slot is a - unit of computational power in BigQuery, and serves as the - unit of parallelism. + Optional. Baseline slots available to this reservation. A + slot is a unit of computational power in BigQuery, and + serves as the unit of parallelism. Queries using this reservation might use more slots during runtime if ignore_idle_slots is set to false, or autoscaling @@ -145,26 +152,25 @@ class Reservation(proto.Message): baseline slots exceed your committed slots. Otherwise, you can decrease your baseline slots every few minutes. ignore_idle_slots (bool): - If false, any query or pipeline job using this reservation - will use idle slots from other reservations within the same - admin project. If true, a query or pipeline job using this - reservation will execute with the slot capacity specified in - the slot_capacity field at most. + Optional. If false, any query or pipeline job using this + reservation will use idle slots from other reservations + within the same admin project. If true, a query or pipeline + job using this reservation will execute with the slot + capacity specified in the slot_capacity field at most. autoscale (google.cloud.bigquery_reservation_v1.types.Reservation.Autoscale): - The configuration parameters for the auto - scaling feature. + Optional. The configuration parameters for + the auto scaling feature. concurrency (int): - Job concurrency target which sets a soft - upper bound on the number of jobs that can run - concurrently in this reservation. This is a soft - target due to asynchronous nature of the system - and various optimizations for small queries. - Default value is 0 which means that concurrency - target will be automatically computed by the - system. - NOTE: this field is exposed as target job - concurrency in the Information Schema, DDL and - BigQuery CLI. + Optional. Job concurrency target which sets a + soft upper bound on the number of jobs that can + run concurrently in this reservation. This is a + soft target due to asynchronous nature of the + system and various optimizations for small + queries. Default value is 0 which means that + concurrency target will be automatically + computed by the system. NOTE: this field is + exposed as target job concurrency in the + Information Schema, DDL and BigQuery CLI. creation_time (google.protobuf.timestamp_pb2.Timestamp): Output only. Creation time of the reservation. @@ -185,7 +191,7 @@ class Reservation(proto.Message): NOTE: this is a preview feature. Project must be allow-listed in order to set this field. edition (google.cloud.bigquery_reservation_v1.types.Edition): - Edition of the reservation. + Optional. Edition of the reservation. primary_location (str): Output only. The current location of the reservation's primary replica. This field is @@ -219,16 +225,19 @@ class Reservation(proto.Message): - baseline. This field must be set together with the scaling_mode enum - value. + value, otherwise the request will be rejected with error + code ``google.rpc.Code.INVALID_ARGUMENT``. If the max_slots and scaling_mode are set, the autoscale or - autoscale.max_slots field must be unset. However, the - autoscale field may still be in the output. The - autopscale.max_slots will always show as 0 and the - autoscaler.current_slots will represent the current slots - from autoscaler excluding idle slots. For example, if the - max_slots is 1000 and scaling_mode is AUTOSCALE_ONLY, then - in the output, the autoscaler.max_slots will be 0 and the + autoscale.max_slots field must be unset. Otherwise the + request will be rejected with error code + ``google.rpc.Code.INVALID_ARGUMENT``. However, the autoscale + field may still be in the output. The autopscale.max_slots + will always show as 0 and the autoscaler.current_slots will + represent the current slots from autoscaler excluding idle + slots. For example, if the max_slots is 1000 and + scaling_mode is AUTOSCALE_ONLY, then in the output, the + autoscaler.max_slots will be 0 and the autoscaler.current_slots may be any value between 0 and 1000. @@ -243,13 +252,15 @@ class Reservation(proto.Message): If the max_slots and scaling_mode are set, then the ignore_idle_slots field must be aligned with the scaling_mode enum value.(See details in ScalingMode - comments). + comments). Otherwise the request will be rejected with error + code ``google.rpc.Code.INVALID_ARGUMENT``. Please note, the max_slots is for user to manage the part of slots greater than the baseline. Therefore, we don't allow users to set max_slots smaller or equal to the baseline as it will not be meaningful. If the field is present and - slot_capacity>=max_slots. + slot_capacity>=max_slots, requests will be rejected with + error code ``google.rpc.Code.INVALID_ARGUMENT``. Please note that if max_slots is set to 0, we will treat it as unset. Customers can set max_slots to 0 and set @@ -259,7 +270,22 @@ class Reservation(proto.Message): This field is a member of `oneof`_ ``_max_slots``. scaling_mode (google.cloud.bigquery_reservation_v1.types.Reservation.ScalingMode): Optional. The scaling mode for the reservation. If the field - is present but max_slots is not present. + is present but max_slots is not present, requests will be + rejected with error code + ``google.rpc.Code.INVALID_ARGUMENT``. + labels (MutableMapping[str, str]): + Optional. The labels associated with this + reservation. You can use these to organize and + group your reservations. You can set this + property when you create or update a + reservation. + reservation_group (str): + Optional. The reservation group that this reservation + belongs to. You can set this property when you create or + update a reservation. Reservations do not need to belong to + a reservation group. Format: + projects/{project}/locations/{location}/reservationGroups/{reservation_group} + or just {reservation_group} replication_status (google.cloud.bigquery_reservation_v1.types.Reservation.ReplicationStatus): Output only. The Disaster Recovery(DR) replication status of the reservation. This is @@ -273,6 +299,13 @@ class Reservation(proto.Message): reservation or the reservation is a DR secondary or that any replication operations on the reservation have succeeded. + scheduling_policy (google.cloud.bigquery_reservation_v1.types.SchedulingPolicy): + Optional. The scheduling policy to use for + jobs and queries running under this reservation. + The scheduling policy controls how the + reservation's resources are distributed. + + This feature is not yet generally available. """ class ScalingMode(proto.Enum): @@ -292,7 +325,8 @@ class ScalingMode(proto.Enum): up to 800 slots and no idle slots will be used. Please note, in this mode, the ignore_idle_slots field must - be set to true. + be set to true. Otherwise the request will be rejected with + error code ``google.rpc.Code.INVALID_ARGUMENT``. IDLE_SLOTS_ONLY (2): The reservation will scale up using only idle slots contributed by other reservations or from unassigned @@ -314,7 +348,8 @@ class ScalingMode(proto.Enum): to max_slots. Please note, in this mode, the ignore_idle_slots field must - be set to false. + be set to false. Otherwise the request will be rejected with + error code ``google.rpc.Code.INVALID_ARGUMENT``. ALL_SLOTS (3): The reservation will scale up using all slots available to it. It will use idle slots contributed by other reservations @@ -335,7 +370,8 @@ class ScalingMode(proto.Enum): baseline and 800 autoscaling slots. Please note, in this mode, the ignore_idle_slots field must - be set to false. + be set to false. Otherwise the request will be rejected with + error code ``google.rpc.Code.INVALID_ARGUMENT``. """ SCALING_MODE_UNSPECIFIED = 0 AUTOSCALE_ONLY = 1 @@ -354,7 +390,8 @@ class Autoscale(proto.Message): the original value and could be larger than max_slots for that brief period (less than one minute) max_slots (int): - Number of slots to be scaled when needed. + Optional. Number of slots to be scaled when + needed. """ current_slots: int = proto.Field( @@ -478,11 +515,85 @@ class ReplicationStatus(proto.Message): number=22, enum=ScalingMode, ) + labels: MutableMapping[str, str] = proto.MapField( + proto.STRING, + proto.STRING, + number=23, + ) + reservation_group: str = proto.Field( + proto.STRING, + number=25, + ) replication_status: ReplicationStatus = proto.Field( proto.MESSAGE, number=24, message=ReplicationStatus, ) + scheduling_policy: "SchedulingPolicy" = proto.Field( + proto.MESSAGE, + number=27, + message="SchedulingPolicy", + ) + + +class SchedulingPolicy(proto.Message): + r"""The scheduling policy controls how a reservation's resources + are distributed. + + + .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields + + Attributes: + concurrency (int): + Optional. If present and > 0, the reservation + will attempt to limit the concurrency of jobs + running for any particular project within it to + the given value. + + This feature is not yet generally available. + + This field is a member of `oneof`_ ``_concurrency``. + max_slots (int): + Optional. If present and > 0, the reservation + will attempt to limit the slot consumption of + queries running for any particular project + within it to the given value. + + This feature is not yet generally available. + + This field is a member of `oneof`_ ``_max_slots``. + """ + + concurrency: int = proto.Field( + proto.INT64, + number=1, + optional=True, + ) + max_slots: int = proto.Field( + proto.INT64, + number=2, + optional=True, + ) + + +class ReservationGroup(proto.Message): + r"""A reservation group is a container for reservations. + + Attributes: + name (str): + Identifier. The resource name of the reservation group, + e.g., + ``projects/*/locations/*/reservationGroups/team1-prod``. The + reservation_group_id must only contain lower case + alphanumeric characters or dashes. It must start with a + letter and must not end with a dash. Its maximum length is + 64 characters. + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) class CapacityCommitment(proto.Message): @@ -506,9 +617,10 @@ class CapacityCommitment(proto.Message): characters or dashes. It must start with a letter and must not end with a dash. Its maximum length is 64 characters. slot_count (int): - Number of slots in this commitment. + Optional. Number of slots in this commitment. plan (google.cloud.bigquery_reservation_v1.types.CapacityCommitment.CommitmentPlan): - Capacity commitment commitment plan. + Optional. Capacity commitment commitment + plan. state (google.cloud.bigquery_reservation_v1.types.CapacityCommitment.State): Output only. State of the commitment. commitment_start_time (google.protobuf.timestamp_pb2.Timestamp): @@ -521,15 +633,15 @@ class CapacityCommitment(proto.Message): Output only. The end of the current commitment period. It is applicable only for ACTIVE capacity commitments. Note after renewal, commitment_end_time is the time the renewed - commitment expires. So it would be at a time after + commitment expires. So itwould be at a time after commitment_start_time + committed period, because we don't change commitment_start_time , failure_status (google.rpc.status_pb2.Status): Output only. For FAILED commitment plan, provides the reason of failure. renewal_plan (google.cloud.bigquery_reservation_v1.types.CapacityCommitment.CommitmentPlan): - The plan this capacity commitment is converted to after - commitment_end_time passes. Once the plan is changed, + Optional. The plan this capacity commitment is converted to + after commitment_end_time passes. Once the plan is changed, committed period is extended according to commitment plan. Only applicable for ANNUAL and TRIAL commitments. multi_region_auxiliary (bool): @@ -546,7 +658,7 @@ class CapacityCommitment(proto.Message): NOTE: this is a preview feature. Project must be allow-listed in order to set this field. edition (google.cloud.bigquery_reservation_v1.types.Edition): - Edition of the capacity commitment. + Optional. Edition of the capacity commitment. is_flat_rate (bool): Output only. If true, the commitment is a flat-rate commitment, otherwise, it's an edition @@ -867,6 +979,131 @@ class FailoverReservationRequest(proto.Message): ) +class CreateReservationGroupRequest(proto.Message): + r"""The request for + [ReservationService.CreateReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.CreateReservationGroup]. + + Attributes: + parent (str): + Required. Project, location. E.g., + ``projects/myproject/locations/US`` + reservation_group_id (str): + Required. The reservation group ID. It must + only contain lower case alphanumeric characters + or dashes. It must start with a letter and must + not end with a dash. Its maximum length is 64 + characters. + reservation_group (google.cloud.bigquery_reservation_v1.types.ReservationGroup): + Required. New Reservation Group to create. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + reservation_group_id: str = proto.Field( + proto.STRING, + number=2, + ) + reservation_group: "ReservationGroup" = proto.Field( + proto.MESSAGE, + number=3, + message="ReservationGroup", + ) + + +class GetReservationGroupRequest(proto.Message): + r"""The request for + [ReservationService.GetReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.GetReservationGroup]. + + Attributes: + name (str): + Required. Resource name of the reservation group to + retrieve. E.g., + ``projects/myproject/locations/US/reservationGroups/team1-prod`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class ListReservationGroupsRequest(proto.Message): + r"""The request for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + + Attributes: + parent (str): + Required. The parent resource name containing project and + location, e.g.: ``projects/myproject/locations/US`` + page_size (int): + The maximum number of items to return per + page. + page_token (str): + The next_page_token value returned from a previous List + request, if any. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + page_size: int = proto.Field( + proto.INT32, + number=2, + ) + page_token: str = proto.Field( + proto.STRING, + number=3, + ) + + +class ListReservationGroupsResponse(proto.Message): + r"""The response for + [ReservationService.ListReservationGroups][google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups]. + + Attributes: + reservation_groups (MutableSequence[google.cloud.bigquery_reservation_v1.types.ReservationGroup]): + List of reservations visible to the user. + next_page_token (str): + Token to retrieve the next page of results, + or empty if there are no more results in the + list. + """ + + @property + def raw_page(self): + return self + + reservation_groups: MutableSequence["ReservationGroup"] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message="ReservationGroup", + ) + next_page_token: str = proto.Field( + proto.STRING, + number=2, + ) + + +class DeleteReservationGroupRequest(proto.Message): + r"""The request for + [ReservationService.DeleteReservationGroup][google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservationGroup]. + + Attributes: + name (str): + Required. Resource name of the reservation group to + retrieve. E.g., + ``projects/myproject/locations/US/reservationGroups/team1-prod`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + class CreateCapacityCommitmentRequest(proto.Message): r"""The request for [ReservationService.CreateCapacityCommitment][google.cloud.bigquery.reservation.v1.ReservationService.CreateCapacityCommitment]. @@ -1098,6 +1335,14 @@ class MergeCapacityCommitmentsRequest(proto.Message): ID is the last portion of capacity commitment name e.g., 'abc' for projects/myproject/locations/US/capacityCommitments/abc + capacity_commitment_id (str): + Optional. The optional resulting capacity + commitment ID. Capacity commitment name will be + generated automatically if this field is empty. + This field must only contain lower case + alphanumeric characters or dashes. The first and + last character cannot be a dash. Max length is + 64 characters. """ parent: str = proto.Field( @@ -1108,6 +1353,10 @@ class MergeCapacityCommitmentsRequest(proto.Message): proto.STRING, number=2, ) + capacity_commitment_id: str = proto.Field( + proto.STRING, + number=3, + ) class Assignment(proto.Message): @@ -1121,11 +1370,12 @@ class Assignment(proto.Message): The assignment_id must only contain lower case alphanumeric characters or dashes and the max length is 64 characters. assignee (str): - The resource which will use the reservation. E.g. + Optional. The resource which will use the reservation. E.g. ``projects/myproject``, ``folders/123``, or ``organizations/456``. job_type (google.cloud.bigquery_reservation_v1.types.Assignment.JobType): - Which type of jobs will use the reservation. + Optional. Which type of jobs will use the + reservation. state (google.cloud.bigquery_reservation_v1.types.Assignment.State): Output only. State of the assignment. enable_gemini_in_bigquery (bool): @@ -1138,6 +1388,15 @@ class Assignment(proto.Message): parent reservation edition is ENTERPRISE_PLUS, then the assignment will give the grantee project/organization access to "Gemini in BigQuery" features. + scheduling_policy (google.cloud.bigquery_reservation_v1.types.SchedulingPolicy): + Optional. The scheduling policy to use for + jobs and queries of this assignee when running + under the associated reservation. The scheduling + policy controls how the reservation's resources + are distributed. This overrides the default + scheduling policy specified on the reservation. + + This feature is not yet generally available. """ class JobType(proto.Enum): @@ -1166,6 +1425,25 @@ class JobType(proto.Enum): reservation. Reservations with continuous assignments cannot be mixed with non-continuous assignments. + BACKGROUND_CHANGE_DATA_CAPTURE (7): + Finer granularity background jobs for + capturing changes in a source database and + streaming them into BigQuery. Reservations with + this job type take priority over a default + BACKGROUND reservation assignment (if it + exists). + BACKGROUND_COLUMN_METADATA_INDEX (8): + Finer granularity background jobs for + refreshing cached metadata for BigQuery tables. + Reservations with this job type take priority + over a default BACKGROUND reservation assignment + (if it exists). + BACKGROUND_SEARCH_INDEX_REFRESH (9): + Finer granularity background jobs for + refreshing search indexes upon BigQuery table + columns. Reservations with this job type take + priority over a default BACKGROUND reservation + assignment (if it exists). """ JOB_TYPE_UNSPECIFIED = 0 PIPELINE = 1 @@ -1173,6 +1451,9 @@ class JobType(proto.Enum): ML_EXTERNAL = 3 BACKGROUND = 4 CONTINUOUS = 6 + BACKGROUND_CHANGE_DATA_CAPTURE = 7 + BACKGROUND_COLUMN_METADATA_INDEX = 8 + BACKGROUND_SEARCH_INDEX_REFRESH = 9 class State(proto.Enum): r"""Assignment will remain in PENDING state if no active capacity @@ -1214,6 +1495,11 @@ class State(proto.Enum): proto.BOOL, number=10, ) + scheduling_policy: "SchedulingPolicy" = proto.Field( + proto.MESSAGE, + number=11, + message="SchedulingPolicy", + ) class CreateAssignmentRequest(proto.Message): @@ -1549,11 +1835,14 @@ class TableReference(proto.Message): Attributes: project_id (str): - The assigned project ID of the project. + Optional. The assigned project ID of the + project. dataset_id (str): - The ID of the dataset in the above project. + Optional. The ID of the dataset in the above + project. table_id (str): - The ID of the table in the above dataset. + Optional. The ID of the table in the above + dataset. """ project_id: str = proto.Field( @@ -1575,16 +1864,17 @@ class BiReservation(proto.Message): Attributes: name (str): - The resource name of the singleton BI reservation. - Reservation names have the form + Identifier. The resource name of the singleton BI + reservation. Reservation names have the form ``projects/{project_id}/locations/{location_id}/biReservation``. update_time (google.protobuf.timestamp_pb2.Timestamp): Output only. The last update timestamp of a reservation. size (int): - Size of a reservation, in bytes. + Optional. Size of a reservation, in bytes. preferred_tables (MutableSequence[google.cloud.bigquery_reservation_v1.types.TableReference]): - Preferred tables to use BI capacity for. + Optional. Preferred tables to use BI capacity + for. """ name: str = proto.Field( diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_create_reservation_group_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_create_reservation_group_async.py new file mode 100644 index 000000000000..67f90605b006 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_create_reservation_group_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateReservationGroup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_CreateReservationGroup_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +async def sample_create_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.CreateReservationGroupRequest( + parent="parent_value", + reservation_group_id="reservation_group_id_value", + ) + + # Make the request + response = await client.create_reservation_group(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_CreateReservationGroup_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_create_reservation_group_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_create_reservation_group_sync.py new file mode 100644 index 000000000000..07280cec9a5d --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_create_reservation_group_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateReservationGroup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_CreateReservationGroup_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +def sample_create_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.CreateReservationGroupRequest( + parent="parent_value", + reservation_group_id="reservation_group_id_value", + ) + + # Make the request + response = client.create_reservation_group(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_CreateReservationGroup_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_async.py new file mode 100644 index 000000000000..abe35d53fc7d --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_async.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteReservationGroup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_DeleteReservationGroup_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +async def sample_delete_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.DeleteReservationGroupRequest( + name="name_value", + ) + + # Make the request + await client.delete_reservation_group(request=request) + + +# [END bigqueryreservation_v1_generated_ReservationService_DeleteReservationGroup_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_sync.py new file mode 100644 index 000000000000..949130fd02eb --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_sync.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteReservationGroup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_DeleteReservationGroup_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +def sample_delete_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.DeleteReservationGroupRequest( + name="name_value", + ) + + # Make the request + client.delete_reservation_group(request=request) + + +# [END bigqueryreservation_v1_generated_ReservationService_DeleteReservationGroup_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_iam_policy_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_iam_policy_async.py new file mode 100644 index 000000000000..d1551d5fbf8f --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_iam_policy_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetIamPolicy +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_GetIamPolicy_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 +from google.iam.v1 import iam_policy_pb2 # type: ignore + + +async def sample_get_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = iam_policy_pb2.GetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = await client.get_iam_policy(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_GetIamPolicy_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_iam_policy_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_iam_policy_sync.py new file mode 100644 index 000000000000..d03d29ba4235 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_iam_policy_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetIamPolicy +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_GetIamPolicy_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 +from google.iam.v1 import iam_policy_pb2 # type: ignore + + +def sample_get_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = iam_policy_pb2.GetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = client.get_iam_policy(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_GetIamPolicy_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_reservation_group_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_reservation_group_async.py new file mode 100644 index 000000000000..b224b51643c2 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_reservation_group_async.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetReservationGroup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_GetReservationGroup_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +async def sample_get_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.GetReservationGroupRequest( + name="name_value", + ) + + # Make the request + response = await client.get_reservation_group(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_GetReservationGroup_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_reservation_group_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_reservation_group_sync.py new file mode 100644 index 000000000000..e812a8c8b314 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_get_reservation_group_sync.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetReservationGroup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_GetReservationGroup_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +def sample_get_reservation_group(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.GetReservationGroupRequest( + name="name_value", + ) + + # Make the request + response = client.get_reservation_group(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_GetReservationGroup_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_async.py new file mode 100644 index 000000000000..afe0abe68b85 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListReservationGroups +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_ListReservationGroups_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +async def sample_list_reservation_groups(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.ListReservationGroupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_reservation_groups(request=request) + + # Handle the response + async for response in page_result: + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_ListReservationGroups_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_sync.py new file mode 100644 index 000000000000..e7b240a615d7 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListReservationGroups +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_ListReservationGroups_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 + + +def sample_list_reservation_groups(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = bigquery_reservation_v1.ListReservationGroupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_reservation_groups(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_ListReservationGroups_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_set_iam_policy_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_set_iam_policy_async.py new file mode 100644 index 000000000000..2a6c174412c3 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_set_iam_policy_async.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for SetIamPolicy +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_SetIamPolicy_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 +from google.iam.v1 import iam_policy_pb2 # type: ignore + + +async def sample_set_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = iam_policy_pb2.SetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = await client.set_iam_policy(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_SetIamPolicy_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_set_iam_policy_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_set_iam_policy_sync.py new file mode 100644 index 000000000000..2fd8cb712160 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_set_iam_policy_sync.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for SetIamPolicy +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_SetIamPolicy_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 +from google.iam.v1 import iam_policy_pb2 # type: ignore + + +def sample_set_iam_policy(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = iam_policy_pb2.SetIamPolicyRequest( + resource="resource_value", + ) + + # Make the request + response = client.set_iam_policy(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_SetIamPolicy_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_async.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_async.py new file mode 100644 index 000000000000..5e0f734f1f53 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_async.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for TestIamPermissions +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_TestIamPermissions_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 +from google.iam.v1 import iam_policy_pb2 # type: ignore + + +async def sample_test_iam_permissions(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceAsyncClient() + + # Initialize request argument(s) + request = iam_policy_pb2.TestIamPermissionsRequest( + resource="resource_value", + permissions=['permissions_value1', 'permissions_value2'], + ) + + # Make the request + response = await client.test_iam_permissions(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_TestIamPermissions_async] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_sync.py b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_sync.py new file mode 100644 index 000000000000..803f313da341 --- /dev/null +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_sync.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for TestIamPermissions +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-bigquery-reservation + + +# [START bigqueryreservation_v1_generated_ReservationService_TestIamPermissions_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import bigquery_reservation_v1 +from google.iam.v1 import iam_policy_pb2 # type: ignore + + +def sample_test_iam_permissions(): + # Create a client + client = bigquery_reservation_v1.ReservationServiceClient() + + # Initialize request argument(s) + request = iam_policy_pb2.TestIamPermissionsRequest( + resource="resource_value", + permissions=['permissions_value1', 'permissions_value2'], + ) + + # Make the request + response = client.test_iam_permissions(request=request) + + # Handle the response + print(response) + +# [END bigqueryreservation_v1_generated_ReservationService_TestIamPermissions_sync] diff --git a/packages/google-cloud-bigquery-reservation/samples/generated_samples/snippet_metadata_google.cloud.bigquery.reservation.v1.json b/packages/google-cloud-bigquery-reservation/samples/generated_samples/snippet_metadata_google.cloud.bigquery.reservation.v1.json index a2bccf0fed7b..6c2537553261 100644 --- a/packages/google-cloud-bigquery-reservation/samples/generated_samples/snippet_metadata_google.cloud.bigquery.reservation.v1.json +++ b/packages/google-cloud-bigquery-reservation/samples/generated_samples/snippet_metadata_google.cloud.bigquery.reservation.v1.json @@ -8,7 +8,7 @@ ], "language": "PYTHON", "name": "google-cloud-bigquery-reservation", - "version": "1.19.0" + "version": "0.1.0" }, "snippets": [ { @@ -349,6 +349,159 @@ ], "title": "bigqueryreservation_v1_generated_reservation_service_create_capacity_commitment_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.create_reservation_group", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.CreateReservationGroup", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "CreateReservationGroup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.CreateReservationGroupRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.types.ReservationGroup", + "shortName": "create_reservation_group" + }, + "description": "Sample for CreateReservationGroup", + "file": "bigqueryreservation_v1_generated_reservation_service_create_reservation_group_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_CreateReservationGroup_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_create_reservation_group_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.create_reservation_group", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.CreateReservationGroup", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "CreateReservationGroup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.CreateReservationGroupRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.types.ReservationGroup", + "shortName": "create_reservation_group" + }, + "description": "Sample for CreateReservationGroup", + "file": "bigqueryreservation_v1_generated_reservation_service_create_reservation_group_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_CreateReservationGroup_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_create_reservation_group_sync.py" + }, { "canonical": true, "clientMethod": { @@ -844,19 +997,19 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", "shortName": "ReservationServiceAsyncClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.delete_reservation", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.delete_reservation_group", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservation", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservationGroup", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "DeleteReservation" + "shortName": "DeleteReservationGroup" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.DeleteReservationRequest" + "type": "google.cloud.bigquery_reservation_v1.types.DeleteReservationGroupRequest" }, { "name": "name", @@ -875,13 +1028,13 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "shortName": "delete_reservation" + "shortName": "delete_reservation_group" }, - "description": "Sample for DeleteReservation", - "file": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_async.py", + "description": "Sample for DeleteReservationGroup", + "file": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_DeleteReservation_async", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_DeleteReservationGroup_async", "segments": [ { "end": 49, @@ -912,7 +1065,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_async.py" + "title": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_async.py" }, { "canonical": true, @@ -921,19 +1074,19 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", "shortName": "ReservationServiceClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.delete_reservation", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.delete_reservation_group", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservation", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservationGroup", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "DeleteReservation" + "shortName": "DeleteReservationGroup" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.DeleteReservationRequest" + "type": "google.cloud.bigquery_reservation_v1.types.DeleteReservationGroupRequest" }, { "name": "name", @@ -952,13 +1105,13 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "shortName": "delete_reservation" + "shortName": "delete_reservation_group" }, - "description": "Sample for DeleteReservation", - "file": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_sync.py", + "description": "Sample for DeleteReservationGroup", + "file": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_DeleteReservation_sync", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_DeleteReservationGroup_sync", "segments": [ { "end": 49, @@ -989,7 +1142,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_sync.py" + "title": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_group_sync.py" }, { "canonical": true, @@ -999,19 +1152,23 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", "shortName": "ReservationServiceAsyncClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.failover_reservation", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.delete_reservation", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.FailoverReservation", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservation", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "FailoverReservation" + "shortName": "DeleteReservation" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.FailoverReservationRequest" + "type": "google.cloud.bigquery_reservation_v1.types.DeleteReservationRequest" + }, + { + "name": "name", + "type": "str" }, { "name": "retry", @@ -1026,22 +1183,21 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.types.Reservation", - "shortName": "failover_reservation" + "shortName": "delete_reservation" }, - "description": "Sample for FailoverReservation", - "file": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_async.py", + "description": "Sample for DeleteReservation", + "file": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_FailoverReservation_async", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_DeleteReservation_async", "segments": [ { - "end": 51, + "end": 49, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 49, "start": 27, "type": "SHORT" }, @@ -1056,17 +1212,15 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 52, - "start": 49, + "end": 50, "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_async.py" + "title": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_async.py" }, { "canonical": true, @@ -1075,19 +1229,23 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", "shortName": "ReservationServiceClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.failover_reservation", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.delete_reservation", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.FailoverReservation", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.DeleteReservation", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "FailoverReservation" + "shortName": "DeleteReservation" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.FailoverReservationRequest" + "type": "google.cloud.bigquery_reservation_v1.types.DeleteReservationRequest" + }, + { + "name": "name", + "type": "str" }, { "name": "retry", @@ -1102,22 +1260,21 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.types.Reservation", - "shortName": "failover_reservation" + "shortName": "delete_reservation" }, - "description": "Sample for FailoverReservation", - "file": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_sync.py", + "description": "Sample for DeleteReservation", + "file": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_FailoverReservation_sync", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_DeleteReservation_sync", "segments": [ { - "end": 51, + "end": 49, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 49, "start": 27, "type": "SHORT" }, @@ -1132,17 +1289,15 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 52, - "start": 49, + "end": 50, "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_sync.py" + "title": "bigqueryreservation_v1_generated_reservation_service_delete_reservation_sync.py" }, { "canonical": true, @@ -1152,23 +1307,19 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", "shortName": "ReservationServiceAsyncClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.get_bi_reservation", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.failover_reservation", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetBiReservation", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.FailoverReservation", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "GetBiReservation" + "shortName": "FailoverReservation" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.GetBiReservationRequest" - }, - { - "name": "name", - "type": "str" + "type": "google.cloud.bigquery_reservation_v1.types.FailoverReservationRequest" }, { "name": "retry", @@ -1183,14 +1334,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.types.BiReservation", - "shortName": "get_bi_reservation" + "resultType": "google.cloud.bigquery_reservation_v1.types.Reservation", + "shortName": "failover_reservation" }, - "description": "Sample for GetBiReservation", - "file": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_async.py", + "description": "Sample for FailoverReservation", + "file": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetBiReservation_async", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_FailoverReservation_async", "segments": [ { "end": 51, @@ -1223,7 +1374,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_async.py" + "title": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_async.py" }, { "canonical": true, @@ -1232,23 +1383,19 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", "shortName": "ReservationServiceClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.get_bi_reservation", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.failover_reservation", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetBiReservation", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.FailoverReservation", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "GetBiReservation" + "shortName": "FailoverReservation" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.GetBiReservationRequest" - }, - { - "name": "name", - "type": "str" + "type": "google.cloud.bigquery_reservation_v1.types.FailoverReservationRequest" }, { "name": "retry", @@ -1263,14 +1410,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.types.BiReservation", - "shortName": "get_bi_reservation" + "resultType": "google.cloud.bigquery_reservation_v1.types.Reservation", + "shortName": "failover_reservation" }, - "description": "Sample for GetBiReservation", - "file": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_sync.py", + "description": "Sample for FailoverReservation", + "file": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetBiReservation_sync", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_FailoverReservation_sync", "segments": [ { "end": 51, @@ -1303,7 +1450,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_sync.py" + "title": "bigqueryreservation_v1_generated_reservation_service_failover_reservation_sync.py" }, { "canonical": true, @@ -1313,19 +1460,502 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", "shortName": "ReservationServiceAsyncClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.get_capacity_commitment", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.get_bi_reservation", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetBiReservation", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "GetBiReservation" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.GetBiReservationRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.types.BiReservation", + "shortName": "get_bi_reservation" + }, + "description": "Sample for GetBiReservation", + "file": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetBiReservation_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.get_bi_reservation", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetBiReservation", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "GetBiReservation" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.GetBiReservationRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.types.BiReservation", + "shortName": "get_bi_reservation" + }, + "description": "Sample for GetBiReservation", + "file": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetBiReservation_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_get_bi_reservation_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.get_capacity_commitment", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetCapacityCommitment", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "GetCapacityCommitment" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.GetCapacityCommitmentRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.types.CapacityCommitment", + "shortName": "get_capacity_commitment" + }, + "description": "Sample for GetCapacityCommitment", + "file": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetCapacityCommitment_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.get_capacity_commitment", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetCapacityCommitment", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "GetCapacityCommitment" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.GetCapacityCommitmentRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.types.CapacityCommitment", + "shortName": "get_capacity_commitment" + }, + "description": "Sample for GetCapacityCommitment", + "file": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetCapacityCommitment_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.get_iam_policy", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetIamPolicy", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "GetIamPolicy" + }, + "parameters": [ + { + "name": "request", + "type": "google.iam.v1.iam_policy_pb2.GetIamPolicyRequest" + }, + { + "name": "resource", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.iam.v1.policy_pb2.Policy", + "shortName": "get_iam_policy" + }, + "description": "Sample for GetIamPolicy", + "file": "bigqueryreservation_v1_generated_reservation_service_get_iam_policy_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetIamPolicy_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 41, + "start": 39, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 42, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_get_iam_policy_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.get_iam_policy", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetCapacityCommitment", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetIamPolicy", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "GetCapacityCommitment" + "shortName": "GetIamPolicy" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.GetCapacityCommitmentRequest" + "type": "google.iam.v1.iam_policy_pb2.GetIamPolicyRequest" + }, + { + "name": "resource", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.iam.v1.policy_pb2.Policy", + "shortName": "get_iam_policy" + }, + "description": "Sample for GetIamPolicy", + "file": "bigqueryreservation_v1_generated_reservation_service_get_iam_policy_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetIamPolicy_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 41, + "start": 39, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 42, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_get_iam_policy_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.get_reservation_group", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetReservationGroup", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "GetReservationGroup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.GetReservationGroupRequest" }, { "name": "name", @@ -1344,14 +1974,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.types.CapacityCommitment", - "shortName": "get_capacity_commitment" + "resultType": "google.cloud.bigquery_reservation_v1.types.ReservationGroup", + "shortName": "get_reservation_group" }, - "description": "Sample for GetCapacityCommitment", - "file": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_async.py", + "description": "Sample for GetReservationGroup", + "file": "bigqueryreservation_v1_generated_reservation_service_get_reservation_group_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetCapacityCommitment_async", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetReservationGroup_async", "segments": [ { "end": 51, @@ -1384,7 +2014,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_async.py" + "title": "bigqueryreservation_v1_generated_reservation_service_get_reservation_group_async.py" }, { "canonical": true, @@ -1393,19 +2023,19 @@ "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", "shortName": "ReservationServiceClient" }, - "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.get_capacity_commitment", + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.get_reservation_group", "method": { - "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetCapacityCommitment", + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.GetReservationGroup", "service": { "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", "shortName": "ReservationService" }, - "shortName": "GetCapacityCommitment" + "shortName": "GetReservationGroup" }, "parameters": [ { "name": "request", - "type": "google.cloud.bigquery_reservation_v1.types.GetCapacityCommitmentRequest" + "type": "google.cloud.bigquery_reservation_v1.types.GetReservationGroupRequest" }, { "name": "name", @@ -1424,14 +2054,14 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.types.CapacityCommitment", - "shortName": "get_capacity_commitment" + "resultType": "google.cloud.bigquery_reservation_v1.types.ReservationGroup", + "shortName": "get_reservation_group" }, - "description": "Sample for GetCapacityCommitment", - "file": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_sync.py", + "description": "Sample for GetReservationGroup", + "file": "bigqueryreservation_v1_generated_reservation_service_get_reservation_group_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetCapacityCommitment_sync", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_GetReservationGroup_sync", "segments": [ { "end": 51, @@ -1464,7 +2094,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_get_capacity_commitment_sync.py" + "title": "bigqueryreservation_v1_generated_reservation_service_get_reservation_group_sync.py" }, { "canonical": true, @@ -1907,14 +2537,175 @@ "type": "Sequence[Tuple[str, Union[str, bytes]]]" } ], - "resultType": "google.cloud.bigquery_reservation_v1.services.reservation_service.pagers.ListCapacityCommitmentsPager", - "shortName": "list_capacity_commitments" + "resultType": "google.cloud.bigquery_reservation_v1.services.reservation_service.pagers.ListCapacityCommitmentsPager", + "shortName": "list_capacity_commitments" + }, + "description": "Sample for ListCapacityCommitments", + "file": "bigqueryreservation_v1_generated_reservation_service_list_capacity_commitments_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_ListCapacityCommitments_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_list_capacity_commitments_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.list_reservation_groups", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "ListReservationGroups" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.ListReservationGroupsRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.services.reservation_service.pagers.ListReservationGroupsAsyncPager", + "shortName": "list_reservation_groups" + }, + "description": "Sample for ListReservationGroups", + "file": "bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_ListReservationGroups_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.list_reservation_groups", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.ListReservationGroups", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "ListReservationGroups" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.bigquery_reservation_v1.types.ListReservationGroupsRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.cloud.bigquery_reservation_v1.services.reservation_service.pagers.ListReservationGroupsPager", + "shortName": "list_reservation_groups" }, - "description": "Sample for ListCapacityCommitments", - "file": "bigqueryreservation_v1_generated_reservation_service_list_capacity_commitments_sync.py", + "description": "Sample for ListReservationGroups", + "file": "bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_sync.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "bigqueryreservation_v1_generated_ReservationService_ListCapacityCommitments_sync", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_ListReservationGroups_sync", "segments": [ { "end": 52, @@ -1947,7 +2738,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "bigqueryreservation_v1_generated_reservation_service_list_capacity_commitments_sync.py" + "title": "bigqueryreservation_v1_generated_reservation_service_list_reservation_groups_sync.py" }, { "canonical": true, @@ -2786,6 +3577,167 @@ ], "title": "bigqueryreservation_v1_generated_reservation_service_search_assignments_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.set_iam_policy", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.SetIamPolicy", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "SetIamPolicy" + }, + "parameters": [ + { + "name": "request", + "type": "google.iam.v1.iam_policy_pb2.SetIamPolicyRequest" + }, + { + "name": "resource", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.iam.v1.policy_pb2.Policy", + "shortName": "set_iam_policy" + }, + "description": "Sample for SetIamPolicy", + "file": "bigqueryreservation_v1_generated_reservation_service_set_iam_policy_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_SetIamPolicy_async", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 41, + "start": 39, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 42, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_set_iam_policy_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.set_iam_policy", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.SetIamPolicy", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "SetIamPolicy" + }, + "parameters": [ + { + "name": "request", + "type": "google.iam.v1.iam_policy_pb2.SetIamPolicyRequest" + }, + { + "name": "resource", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.iam.v1.policy_pb2.Policy", + "shortName": "set_iam_policy" + }, + "description": "Sample for SetIamPolicy", + "file": "bigqueryreservation_v1_generated_reservation_service_set_iam_policy_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_SetIamPolicy_sync", + "segments": [ + { + "end": 52, + "start": 27, + "type": "FULL" + }, + { + "end": 52, + "start": 27, + "type": "SHORT" + }, + { + "end": 41, + "start": 39, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 46, + "start": 42, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 49, + "start": 47, + "type": "REQUEST_EXECUTION" + }, + { + "end": 53, + "start": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_set_iam_policy_sync.py" + }, { "canonical": true, "clientMethod": { @@ -2955,6 +3907,159 @@ ], "title": "bigqueryreservation_v1_generated_reservation_service_split_capacity_commitment_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient", + "shortName": "ReservationServiceAsyncClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceAsyncClient.test_iam_permissions", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.TestIamPermissions", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "TestIamPermissions" + }, + "parameters": [ + { + "name": "request", + "type": "google.iam.v1.iam_policy_pb2.TestIamPermissionsRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.iam.v1.iam_policy_pb2.TestIamPermissionsResponse", + "shortName": "test_iam_permissions" + }, + "description": "Sample for TestIamPermissions", + "file": "bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_TestIamPermissions_async", + "segments": [ + { + "end": 53, + "start": 27, + "type": "FULL" + }, + { + "end": 53, + "start": 27, + "type": "SHORT" + }, + { + "end": 41, + "start": 39, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 47, + "start": 42, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 50, + "start": 48, + "type": "REQUEST_EXECUTION" + }, + { + "end": 54, + "start": 51, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient", + "shortName": "ReservationServiceClient" + }, + "fullName": "google.cloud.bigquery_reservation_v1.ReservationServiceClient.test_iam_permissions", + "method": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService.TestIamPermissions", + "service": { + "fullName": "google.cloud.bigquery.reservation.v1.ReservationService", + "shortName": "ReservationService" + }, + "shortName": "TestIamPermissions" + }, + "parameters": [ + { + "name": "request", + "type": "google.iam.v1.iam_policy_pb2.TestIamPermissionsRequest" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "resultType": "google.iam.v1.iam_policy_pb2.TestIamPermissionsResponse", + "shortName": "test_iam_permissions" + }, + "description": "Sample for TestIamPermissions", + "file": "bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "bigqueryreservation_v1_generated_ReservationService_TestIamPermissions_sync", + "segments": [ + { + "end": 53, + "start": 27, + "type": "FULL" + }, + { + "end": 53, + "start": 27, + "type": "SHORT" + }, + { + "end": 41, + "start": 39, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 47, + "start": 42, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 50, + "start": 48, + "type": "REQUEST_EXECUTION" + }, + { + "end": 54, + "start": 51, + "type": "RESPONSE_HANDLING" + } + ], + "title": "bigqueryreservation_v1_generated_reservation_service_test_iam_permissions_sync.py" + }, { "canonical": true, "clientMethod": { diff --git a/packages/google-cloud-bigquery-reservation/scripts/fixup_bigquery_reservation_v1_keywords.py b/packages/google-cloud-bigquery-reservation/scripts/fixup_bigquery_reservation_v1_keywords.py index c97f0fa331cf..1bcaf6d5ab34 100644 --- a/packages/google-cloud-bigquery-reservation/scripts/fixup_bigquery_reservation_v1_keywords.py +++ b/packages/google-cloud-bigquery-reservation/scripts/fixup_bigquery_reservation_v1_keywords.py @@ -42,21 +42,28 @@ class bigquery_reservationCallTransformer(cst.CSTTransformer): 'create_assignment': ('parent', 'assignment', 'assignment_id', ), 'create_capacity_commitment': ('parent', 'capacity_commitment', 'enforce_single_admin_project_per_org', 'capacity_commitment_id', ), 'create_reservation': ('parent', 'reservation_id', 'reservation', ), + 'create_reservation_group': ('parent', 'reservation_group_id', 'reservation_group', ), 'delete_assignment': ('name', ), 'delete_capacity_commitment': ('name', 'force', ), 'delete_reservation': ('name', ), + 'delete_reservation_group': ('name', ), 'failover_reservation': ('name', 'failover_mode', ), 'get_bi_reservation': ('name', ), 'get_capacity_commitment': ('name', ), + 'get_iam_policy': ('resource', 'options', ), 'get_reservation': ('name', ), + 'get_reservation_group': ('name', ), 'list_assignments': ('parent', 'page_size', 'page_token', ), 'list_capacity_commitments': ('parent', 'page_size', 'page_token', ), + 'list_reservation_groups': ('parent', 'page_size', 'page_token', ), 'list_reservations': ('parent', 'page_size', 'page_token', ), - 'merge_capacity_commitments': ('parent', 'capacity_commitment_ids', ), + 'merge_capacity_commitments': ('parent', 'capacity_commitment_ids', 'capacity_commitment_id', ), 'move_assignment': ('name', 'destination_id', 'assignment_id', ), 'search_all_assignments': ('parent', 'query', 'page_size', 'page_token', ), 'search_assignments': ('parent', 'query', 'page_size', 'page_token', ), + 'set_iam_policy': ('resource', 'policy', 'update_mask', ), 'split_capacity_commitment': ('name', 'slot_count', ), + 'test_iam_permissions': ('resource', 'permissions', ), 'update_assignment': ('assignment', 'update_mask', ), 'update_bi_reservation': ('bi_reservation', 'update_mask', ), 'update_capacity_commitment': ('capacity_commitment', 'update_mask', ), diff --git a/packages/google-cloud-bigquery-reservation/setup.py b/packages/google-cloud-bigquery-reservation/setup.py index a245620cdae0..254bae4e9084 100644 --- a/packages/google-cloud-bigquery-reservation/setup.py +++ b/packages/google-cloud-bigquery-reservation/setup.py @@ -48,6 +48,7 @@ "proto-plus >= 1.22.3, <2.0.0", "proto-plus >= 1.25.0, <2.0.0; python_version >= '3.13'", "protobuf>=3.20.2,<7.0.0,!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5", + "grpc-google-iam-v1 >= 0.14.0, <1.0.0", ] extras = {} url = "https://github.com/googleapis/google-cloud-python/tree/main/packages/google-cloud-bigquery-reservation" diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.10.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.10.txt index ed7f9aed2559..ad3f0fa58e2d 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.10.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.10.txt @@ -4,3 +4,4 @@ google-api-core proto-plus protobuf +grpc-google-iam-v1 diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.11.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.11.txt index ed7f9aed2559..ad3f0fa58e2d 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.11.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.11.txt @@ -4,3 +4,4 @@ google-api-core proto-plus protobuf +grpc-google-iam-v1 diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.12.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.12.txt index ed7f9aed2559..ad3f0fa58e2d 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.12.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.12.txt @@ -4,3 +4,4 @@ google-api-core proto-plus protobuf +grpc-google-iam-v1 diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.13.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.13.txt index c20a77817caa..2010e549cceb 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.13.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.13.txt @@ -9,3 +9,4 @@ google-api-core>=2 google-auth>=2 proto-plus>=1 protobuf>=6 +grpc-google-iam-v1>=0 diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.7.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.7.txt index a77f12bc13e4..56affbd9bd75 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.7.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.7.txt @@ -8,3 +8,4 @@ google-api-core==1.34.1 google-auth==2.14.1 proto-plus==1.22.3 protobuf==3.20.2 +grpc-google-iam-v1==0.14.0 diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.8.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.8.txt index ed7f9aed2559..ad3f0fa58e2d 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.8.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.8.txt @@ -4,3 +4,4 @@ google-api-core proto-plus protobuf +grpc-google-iam-v1 diff --git a/packages/google-cloud-bigquery-reservation/testing/constraints-3.9.txt b/packages/google-cloud-bigquery-reservation/testing/constraints-3.9.txt index ed7f9aed2559..ad3f0fa58e2d 100644 --- a/packages/google-cloud-bigquery-reservation/testing/constraints-3.9.txt +++ b/packages/google-cloud-bigquery-reservation/testing/constraints-3.9.txt @@ -4,3 +4,4 @@ google-api-core proto-plus protobuf +grpc-google-iam-v1 diff --git a/packages/google-cloud-bigquery-reservation/tests/unit/gapic/bigquery_reservation_v1/test_reservation_service.py b/packages/google-cloud-bigquery-reservation/tests/unit/gapic/bigquery_reservation_v1/test_reservation_service.py index b6079f81b9e9..aab1b11237bc 100644 --- a/packages/google-cloud-bigquery-reservation/tests/unit/gapic/bigquery_reservation_v1/test_reservation_service.py +++ b/packages/google-cloud-bigquery-reservation/tests/unit/gapic/bigquery_reservation_v1/test_reservation_service.py @@ -50,11 +50,15 @@ import google.auth from google.auth import credentials as ga_credentials from google.auth.exceptions import MutualTLSChannelError +from google.iam.v1 import iam_policy_pb2 # type: ignore +from google.iam.v1 import options_pb2 # type: ignore +from google.iam.v1 import policy_pb2 # type: ignore from google.oauth2 import service_account from google.protobuf import any_pb2 # type: ignore from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from google.rpc import status_pb2 # type: ignore +from google.type import expr_pb2 # type: ignore from google.cloud.bigquery_reservation_v1.services.reservation_service import ( ReservationServiceAsyncClient, @@ -1194,6 +1198,7 @@ def test_create_reservation(request_type, transport: str = "grpc"): original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) response = client.create_reservation(request) @@ -1218,6 +1223,7 @@ def test_create_reservation(request_type, transport: str = "grpc"): assert ( response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY ) + assert response.reservation_group == "reservation_group_value" def test_create_reservation_non_empty_request_with_auto_populated_field(): @@ -1365,6 +1371,7 @@ async def test_create_reservation_async( original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) ) response = await client.create_reservation(request) @@ -1390,6 +1397,7 @@ async def test_create_reservation_async( assert ( response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY ) + assert response.reservation_group == "reservation_group_value" @pytest.mark.asyncio @@ -2143,6 +2151,7 @@ def test_get_reservation(request_type, transport: str = "grpc"): original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) response = client.get_reservation(request) @@ -2165,6 +2174,7 @@ def test_get_reservation(request_type, transport: str = "grpc"): assert response.original_primary_location == "original_primary_location_value" assert response.max_slots == 986 assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.reservation_group == "reservation_group_value" def test_get_reservation_non_empty_request_with_auto_populated_field(): @@ -2301,6 +2311,7 @@ async def test_get_reservation_async( original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) ) response = await client.get_reservation(request) @@ -2324,6 +2335,7 @@ async def test_get_reservation_async( assert response.original_primary_location == "original_primary_location_value" assert response.max_slots == 986 assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.reservation_group == "reservation_group_value" @pytest.mark.asyncio @@ -2837,6 +2849,7 @@ def test_update_reservation(request_type, transport: str = "grpc"): original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) response = client.update_reservation(request) @@ -2861,6 +2874,7 @@ def test_update_reservation(request_type, transport: str = "grpc"): assert ( response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY ) + assert response.reservation_group == "reservation_group_value" def test_update_reservation_non_empty_request_with_auto_populated_field(): @@ -3002,6 +3016,7 @@ async def test_update_reservation_async( original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) ) response = await client.update_reservation(request) @@ -3027,6 +3042,7 @@ async def test_update_reservation_async( assert ( response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY ) + assert response.reservation_group == "reservation_group_value" @pytest.mark.asyncio @@ -3229,6 +3245,7 @@ def test_failover_reservation(request_type, transport: str = "grpc"): original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) response = client.failover_reservation(request) @@ -3251,6 +3268,7 @@ def test_failover_reservation(request_type, transport: str = "grpc"): assert response.original_primary_location == "original_primary_location_value" assert response.max_slots == 986 assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.reservation_group == "reservation_group_value" def test_failover_reservation_non_empty_request_with_auto_populated_field(): @@ -3395,6 +3413,7 @@ async def test_failover_reservation_async( original_primary_location="original_primary_location_value", max_slots=986, scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) ) response = await client.failover_reservation(request) @@ -3418,6 +3437,7 @@ async def test_failover_reservation_async( assert response.original_primary_location == "original_primary_location_value" assert response.max_slots == 986 assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.reservation_group == "reservation_group_value" @pytest.mark.asyncio @@ -5913,6 +5933,7 @@ def test_merge_capacity_commitments_non_empty_request_with_auto_populated_field( # if they meet the requirements of AIP 4235. request = reservation.MergeCapacityCommitmentsRequest( parent="parent_value", + capacity_commitment_id="capacity_commitment_id_value", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -5927,6 +5948,7 @@ def test_merge_capacity_commitments_non_empty_request_with_auto_populated_field( _, args, _ = call.mock_calls[0] assert args[0] == reservation.MergeCapacityCommitmentsRequest( parent="parent_value", + capacity_commitment_id="capacity_commitment_id_value", ) @@ -9971,13 +9993,79 @@ async def test_update_bi_reservation_flattened_error_async(): ) -def test_create_reservation_rest_use_cached_wrapped_rpc(): +@pytest.mark.parametrize( + "request_type", + [ + iam_policy_pb2.GetIamPolicyRequest, + dict, + ], +) +def test_get_iam_policy(request_type, transport: str = "grpc"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + response = client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = iam_policy_pb2.GetIamPolicyRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + assert response.version == 774 + assert response.etag == b"etag_blob" + + +def test_get_iam_policy_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 = ReservationServiceClient( + 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 = iam_policy_pb2.GetIamPolicyRequest( + resource="resource_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_iam_policy(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == iam_policy_pb2.GetIamPolicyRequest( + resource="resource_value", + ) + + +def test_get_iam_policy_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -9985,188 +10073,339 @@ def test_create_reservation_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.create_reservation in client._transport._wrapped_methods - ) + assert client._transport.get_iam_policy 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_reservation - ] = mock_rpc - + client._transport._wrapped_methods[client._transport.get_iam_policy] = mock_rpc request = {} - client.create_reservation(request) + client.get_iam_policy(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_reservation(request) + client.get_iam_policy(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_reservation_rest_required_fields( - request_type=gcbr_reservation.CreateReservationRequest, +@pytest.mark.asyncio +async def test_get_iam_policy_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.ReservationServiceRestTransport + # Clients should use _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 = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) - ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # verify fields with default values are dropped + # Ensure method has been cached + assert ( + client._client._transport.get_iam_policy + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_reservation._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_iam_policy + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.get_iam_policy(request) - jsonified_request["parent"] = "parent_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_reservation._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("reservation_id",)) - jsonified_request.update(unset_fields) + await client.get_iam_policy(request) - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_get_iam_policy_async( + transport: str = "grpc_asyncio", request_type=iam_policy_pb2.GetIamPolicyRequest +): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = gcbr_reservation.Reservation() - # 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 + # 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.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + ) + response = await client.get_iam_policy(request) - # Convert return value to protobuf type - return_value = gcbr_reservation.Reservation.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 = iam_policy_pb2.GetIamPolicyRequest() + 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, policy_pb2.Policy) + assert response.version == 774 + assert response.etag == b"etag_blob" - response = client.create_reservation(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_get_iam_policy_async_from_dict(): + await test_get_iam_policy_async(request_type=dict) -def test_create_reservation_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_get_iam_policy_field_headers(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.create_reservation._get_unset_required_fields({}) - assert set(unset_fields) == (set(("reservationId",)) & set(("parent",))) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.GetIamPolicyRequest() + request.resource = "resource_value" -def test_create_reservation_rest_flattened(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + call.return_value = policy_pb2.Policy() + client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_iam_policy_field_headers_async(): + client = ReservationServiceAsyncClient( + 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 = gcbr_reservation.Reservation() + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.GetIamPolicyRequest() - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + request.resource = "resource_value" - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - reservation=gcbr_reservation.Reservation(name="name_value"), - reservation_id="reservation_id_value", - ) - mock_args.update(sample_request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + await client.get_iam_policy(request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = gcbr_reservation.Reservation.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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.create_reservation(**mock_args) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource_value", + ) in kw["metadata"] - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}/reservations" - % client.transport._host, - args[1], + +def test_get_iam_policy_from_dict_foreign(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + response = client.get_iam_policy( + request={ + "resource": "resource_value", + "options": options_pb2.GetPolicyOptions(requested_policy_version=2598), + } ) + call.assert_called() -def test_create_reservation_rest_flattened_error(transport: str = "rest"): +def test_get_iam_policy_flattened(): client = ReservationServiceClient( 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_reservation( - gcbr_reservation.CreateReservationRequest(), - parent="parent_value", - reservation=gcbr_reservation.Reservation(name="name_value"), - reservation_id="reservation_id_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_iam_policy( + resource="resource_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].resource + mock_val = "resource_value" + assert arg == mock_val -def test_list_reservations_rest_use_cached_wrapped_rpc(): + +def test_get_iam_policy_flattened_error(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_iam_policy( + iam_policy_pb2.GetIamPolicyRequest(), + resource="resource_value", + ) + + +@pytest.mark.asyncio +async def test_get_iam_policy_flattened_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_iam_policy( + resource="resource_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].resource + mock_val = "resource_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_get_iam_policy_flattened_error_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_iam_policy( + iam_policy_pb2.GetIamPolicyRequest(), + resource="resource_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + iam_policy_pb2.SetIamPolicyRequest, + dict, + ], +) +def test_set_iam_policy(request_type, transport: str = "grpc"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + response = client.set_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = iam_policy_pb2.SetIamPolicyRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + assert response.version == 774 + assert response.etag == b"etag_blob" + + +def test_set_iam_policy_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 = ReservationServiceClient( + 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 = iam_policy_pb2.SetIamPolicyRequest( + resource="resource_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.set_iam_policy(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == iam_policy_pb2.SetIamPolicyRequest( + resource="resource_value", + ) + + +def test_set_iam_policy_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10174,257 +10413,342 @@ def test_list_reservations_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_reservations in client._transport._wrapped_methods + assert client._transport.set_iam_policy 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_reservations - ] = mock_rpc - + client._transport._wrapped_methods[client._transport.set_iam_policy] = mock_rpc request = {} - client.list_reservations(request) + client.set_iam_policy(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_reservations(request) + client.set_iam_policy(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_reservations_rest_required_fields( - request_type=reservation.ListReservationsRequest, +@pytest.mark.asyncio +async def test_set_iam_policy_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.ReservationServiceRestTransport - - 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 + # Clients should use _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 = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_reservations._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # verify required fields with default values are now present + # Ensure method has been cached + assert ( + client._client._transport.set_iam_policy + in client._client._transport._wrapped_methods + ) - jsonified_request["parent"] = "parent_value" + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.set_iam_policy + ] = mock_rpc - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_reservations._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) + request = {} + await client.set_iam_policy(request) - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + await client.set_iam_policy(request) - # Designate an appropriate value for the returned response. - return_value = reservation.ListReservationsResponse() - # 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 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 = reservation.ListReservationsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_set_iam_policy_async( + transport: str = "grpc_asyncio", request_type=iam_policy_pb2.SetIamPolicyRequest +): + client = ReservationServiceAsyncClient( + 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.list_reservations(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + ) + response = await client.set_iam_policy(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 = iam_policy_pb2.SetIamPolicyRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, policy_pb2.Policy) + assert response.version == 774 + assert response.etag == b"etag_blob" -def test_list_reservations_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.list_reservations._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) +@pytest.mark.asyncio +async def test_set_iam_policy_async_from_dict(): + await test_set_iam_policy_async(request_type=dict) -def test_list_reservations_rest_flattened(): +def test_set_iam_policy_field_headers(): client = ReservationServiceClient( 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 = reservation.ListReservationsResponse() + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.SetIamPolicyRequest() - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + request.resource = "resource_value" - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - ) - mock_args.update(sample_request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + call.return_value = policy_pb2.Policy() + client.set_iam_policy(request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = reservation.ListReservationsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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 - client.list_reservations(**mock_args) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_set_iam_policy_field_headers_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.SetIamPolicyRequest() + + request.resource = "resource_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + await client.set_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource_value", + ) in kw["metadata"] + + +def test_set_iam_policy_from_dict_foreign(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + response = client.set_iam_policy( + request={ + "resource": "resource_value", + "policy": policy_pb2.Policy(version=774), + "update_mask": field_mask_pb2.FieldMask(paths=["paths_value"]), + } + ) + call.assert_called() + + +def test_set_iam_policy_flattened(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.set_iam_policy( + resource="resource_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}/reservations" - % client.transport._host, - args[1], - ) + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].resource + mock_val = "resource_value" + assert arg == mock_val -def test_list_reservations_rest_flattened_error(transport: str = "rest"): +def test_set_iam_policy_flattened_error(): client = ReservationServiceClient( 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_reservations( - reservation.ListReservationsRequest(), - parent="parent_value", + client.set_iam_policy( + iam_policy_pb2.SetIamPolicyRequest(), + resource="resource_value", ) -def test_list_reservations_rest_pager(transport: str = "rest"): +@pytest.mark.asyncio +async def test_set_iam_policy_flattened_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = policy_pb2.Policy() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(policy_pb2.Policy()) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.set_iam_policy( + resource="resource_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].resource + mock_val = "resource_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_set_iam_policy_flattened_error_async(): + client = ReservationServiceAsyncClient( + 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.set_iam_policy( + iam_policy_pb2.SetIamPolicyRequest(), + resource="resource_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + iam_policy_pb2.TestIamPermissionsRequest, + dict, + ], +) +def test_test_iam_permissions(request_type, transport: str = "grpc"): client = ReservationServiceClient( 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 = ( - reservation.ListReservationsResponse( - reservations=[ - reservation.Reservation(), - reservation.Reservation(), - reservation.Reservation(), - ], - next_page_token="abc", - ), - reservation.ListReservationsResponse( - reservations=[], - next_page_token="def", - ), - reservation.ListReservationsResponse( - reservations=[ - reservation.Reservation(), - ], - next_page_token="ghi", - ), - reservation.ListReservationsResponse( - reservations=[ - reservation.Reservation(), - reservation.Reservation(), - ], - ), - ) - # 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( - reservation.ListReservationsResponse.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.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = iam_policy_pb2.TestIamPermissionsResponse( + permissions=["permissions_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 + response = client.test_iam_permissions(request) - sample_request = {"parent": "projects/sample1/locations/sample2"} + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = iam_policy_pb2.TestIamPermissionsRequest() + assert args[0] == request - pager = client.list_reservations(request=sample_request) + # Establish that the response is the type that we expect. + assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse) + assert response.permissions == ["permissions_value"] - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, reservation.Reservation) for i in results) - pages = list(client.list_reservations(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +def test_test_iam_permissions_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 = ReservationServiceClient( + 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 = iam_policy_pb2.TestIamPermissionsRequest( + resource="resource_value", + ) -def test_get_reservation_rest_use_cached_wrapped_rpc(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.test_iam_permissions(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == iam_policy_pb2.TestIamPermissionsRequest( + resource="resource_value", + ) + + +def test_test_iam_permissions_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10432,179 +10756,276 @@ def test_get_reservation_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_reservation in client._transport._wrapped_methods + assert ( + client._transport.test_iam_permissions 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_reservation] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.test_iam_permissions + ] = mock_rpc request = {} - client.get_reservation(request) + client.test_iam_permissions(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_reservation(request) + client.test_iam_permissions(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_reservation_rest_required_fields( - request_type=reservation.GetReservationRequest, +@pytest.mark.asyncio +async def test_test_iam_permissions_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.ReservationServiceRestTransport + # Clients should use _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 = ReservationServiceAsyncClient( + 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.test_iam_permissions + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_reservation._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.test_iam_permissions + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.test_iam_permissions(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_reservation._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + await client.test_iam_permissions(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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_test_iam_permissions_async( + transport: str = "grpc_asyncio", + request_type=iam_policy_pb2.TestIamPermissionsRequest, +): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = reservation.Reservation() - # 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.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + iam_policy_pb2.TestIamPermissionsResponse( + permissions=["permissions_value"], + ) + ) + response = await client.test_iam_permissions(request) - # Convert return value to protobuf type - return_value = reservation.Reservation.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 = iam_policy_pb2.TestIamPermissionsRequest() + 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, iam_policy_pb2.TestIamPermissionsResponse) + assert response.permissions == ["permissions_value"] - response = client.get_reservation(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_test_iam_permissions_async_from_dict(): + await test_test_iam_permissions_async(request_type=dict) -def test_get_reservation_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_test_iam_permissions_field_headers(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.get_reservation._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 = iam_policy_pb2.TestIamPermissionsRequest() + request.resource = "resource_value" -def test_get_reservation_rest_flattened(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + call.return_value = iam_policy_pb2.TestIamPermissionsResponse() + client.test_iam_permissions(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_test_iam_permissions_field_headers_async(): + client = ReservationServiceAsyncClient( + 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 = reservation.Reservation() + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = iam_policy_pb2.TestIamPermissionsRequest() - # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/locations/sample2/reservations/sample3" - } + request.resource = "resource_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.test_iam_permissions), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + iam_policy_pb2.TestIamPermissionsResponse() ) - mock_args.update(sample_request) + await client.test_iam_permissions(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 = reservation.Reservation.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_reservation(**mock_args) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "resource=resource_value", + ) in kw["metadata"] - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/reservations/*}" - % client.transport._host, - args[1], + +def test_test_iam_permissions_from_dict_foreign(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = iam_policy_pb2.TestIamPermissionsResponse() + response = client.test_iam_permissions( + request={ + "resource": "resource_value", + "permissions": ["permissions_value"], + } ) + call.assert_called() -def test_get_reservation_rest_flattened_error(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + reservation.CreateReservationGroupRequest, + dict, + ], +) +def test_create_reservation_group(request_type, transport: str = "grpc"): client = ReservationServiceClient( 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_reservation( - reservation.GetReservationRequest(), + # 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_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ReservationGroup( name="name_value", ) + response = client.create_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = reservation.CreateReservationGroupRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, reservation.ReservationGroup) + assert response.name == "name_value" -def test_delete_reservation_rest_use_cached_wrapped_rpc(): + +def test_create_reservation_group_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 = ReservationServiceClient( + 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 = reservation.CreateReservationGroupRequest( + parent="parent_value", + reservation_group_id="reservation_group_id_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation_group), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.create_reservation_group(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == reservation.CreateReservationGroupRequest( + parent="parent_value", + reservation_group_id="reservation_group_id_value", + ) + + +def test_create_reservation_group_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10613,7 +11034,8 @@ def test_delete_reservation_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.delete_reservation in client._transport._wrapped_methods + client._transport.create_reservation_group + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -10622,168 +11044,245 @@ def test_delete_reservation_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_reservation + client._transport.create_reservation_group ] = mock_rpc - request = {} - client.delete_reservation(request) + client.create_reservation_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_reservation(request) + client.create_reservation_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_delete_reservation_rest_required_fields( - request_type=reservation.DeleteReservationRequest, +@pytest.mark.asyncio +async def test_create_reservation_group_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.ReservationServiceRestTransport + # Clients should use _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 = ReservationServiceAsyncClient( + 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_reservation_group + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_reservation._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_reservation_group + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.create_reservation_group(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_reservation._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + await client.create_reservation_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 + + +@pytest.mark.asyncio +async def test_create_reservation_group_async( + transport: str = "grpc_asyncio", + request_type=reservation.CreateReservationGroupRequest, +): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup( + name="name_value", + ) + ) + response = await client.create_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = reservation.CreateReservationGroupRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, reservation.ReservationGroup) + assert response.name == "name_value" + + +@pytest.mark.asyncio +async def test_create_reservation_group_async_from_dict(): + await test_create_reservation_group_async(request_type=dict) - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" +def test_create_reservation_group_field_headers(): client = ReservationServiceClient( 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 + # 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 = reservation.CreateReservationGroupRequest() - response_value = Response() - response_value.status_code = 200 - json_return_value = "" + request.parent = "parent_value" - response_value._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.create_reservation_group), "__call__" + ) as call: + call.return_value = reservation.ReservationGroup() + client.create_reservation_group(request) - response = client.delete_reservation(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", + "parent=parent_value", + ) in kw["metadata"] -def test_delete_reservation_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_create_reservation_group_field_headers_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.delete_reservation._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 = reservation.CreateReservationGroupRequest() + request.parent = "parent_value" -def test_delete_reservation_rest_flattened(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation_group), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup() + ) + await client.create_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.parametrize( + "request_type", + [ + reservation.GetReservationGroupRequest, + dict, + ], +) +def test_get_reservation_group(request_type, transport: str = "grpc"): client = ReservationServiceClient( 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": "projects/sample1/locations/sample2/reservations/sample3" - } + # 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( + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ReservationGroup( 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"} + response = client.get_reservation_group(request) - client.delete_reservation(**mock_args) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = reservation.GetReservationGroupRequest() + 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/v1/{name=projects/*/locations/*/reservations/*}" - % client.transport._host, - args[1], - ) + # Establish that the response is the type that we expect. + assert isinstance(response, reservation.ReservationGroup) + assert response.name == "name_value" -def test_delete_reservation_rest_flattened_error(transport: str = "rest"): +def test_get_reservation_group_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 = ReservationServiceClient( 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_reservation( - reservation.DeleteReservationRequest(), + # 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 = reservation.GetReservationGroupRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_reservation_group(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == reservation.GetReservationGroupRequest( name="name_value", ) -def test_update_reservation_rest_use_cached_wrapped_rpc(): +def test_get_reservation_group_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10792,7 +11291,8 @@ def test_update_reservation_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_reservation in client._transport._wrapped_methods + client._transport.get_reservation_group + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -10801,93 +11301,327 @@ def test_update_reservation_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_reservation + client._transport.get_reservation_group ] = mock_rpc - request = {} - client.update_reservation(request) + client.get_reservation_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_reservation(request) + client.get_reservation_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_reservation_rest_flattened(): - client = ReservationServiceClient( - 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 = gcbr_reservation.Reservation() +@pytest.mark.asyncio +async def test_get_reservation_group_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - # get arguments that satisfy an http rule for this method - sample_request = { - "reservation": { - "name": "projects/sample1/locations/sample2/reservations/sample3" - } - } + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # get truthy value for each flattened field - mock_args = dict( - reservation=gcbr_reservation.Reservation(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + # Ensure method has been cached + assert ( + client._client._transport.get_reservation_group + in client._client._transport._wrapped_methods ) - 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 = gcbr_reservation.Reservation.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # 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_reservation_group + ] = mock_rpc - client.update_reservation(**mock_args) + request = {} + await client.get_reservation_group(request) - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{reservation.name=projects/*/locations/*/reservations/*}" - % client.transport._host, - args[1], + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.get_reservation_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 + + +@pytest.mark.asyncio +async def test_get_reservation_group_async( + transport: str = "grpc_asyncio", request_type=reservation.GetReservationGroupRequest +): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup( + name="name_value", + ) ) + response = await client.get_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = reservation.GetReservationGroupRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, reservation.ReservationGroup) + assert response.name == "name_value" -def test_update_reservation_rest_flattened_error(transport: str = "rest"): +@pytest.mark.asyncio +async def test_get_reservation_group_async_from_dict(): + await test_get_reservation_group_async(request_type=dict) + + +def test_get_reservation_group_field_headers(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = reservation.GetReservationGroupRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + call.return_value = reservation.ReservationGroup() + client.get_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_reservation_group_field_headers_async(): + client = ReservationServiceAsyncClient( + 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 = reservation.GetReservationGroupRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup() + ) + await client.get_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_get_reservation_group_flattened(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ReservationGroup() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_reservation_group( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_get_reservation_group_flattened_error(): client = ReservationServiceClient( 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_reservation( - gcbr_reservation.UpdateReservationRequest(), - reservation=gcbr_reservation.Reservation(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_reservation_group( + reservation.GetReservationGroupRequest(), + name="name_value", ) -def test_failover_reservation_rest_use_cached_wrapped_rpc(): +@pytest.mark.asyncio +async def test_get_reservation_group_flattened_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ReservationGroup() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_reservation_group( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_get_reservation_group_flattened_error_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_reservation_group( + reservation.GetReservationGroupRequest(), + name="name_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + reservation.DeleteReservationGroupRequest, + dict, + ], +) +def test_delete_reservation_group(request_type, transport: str = "grpc"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = reservation.DeleteReservationGroupRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_reservation_group_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 = ReservationServiceClient( + 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 = reservation.DeleteReservationGroupRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_reservation_group(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == reservation.DeleteReservationGroupRequest( + name="name_value", + ) + + +def test_delete_reservation_group_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10896,7 +11630,8 @@ def test_failover_reservation_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.failover_reservation in client._transport._wrapped_methods + client._transport.delete_reservation_group + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -10905,315 +11640,324 @@ def test_failover_reservation_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.failover_reservation + client._transport.delete_reservation_group ] = mock_rpc - request = {} - client.failover_reservation(request) + client.delete_reservation_group(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.failover_reservation(request) + client.delete_reservation_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_failover_reservation_rest_required_fields( - request_type=reservation.FailoverReservationRequest, +@pytest.mark.asyncio +async def test_delete_reservation_group_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.ReservationServiceRestTransport + # Clients should use _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 = ReservationServiceAsyncClient( + 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.delete_reservation_group + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).failover_reservation._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.delete_reservation_group + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.delete_reservation_group(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() - ).failover_reservation._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + await client.delete_reservation_group(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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_delete_reservation_group_async( + transport: str = "grpc_asyncio", + request_type=reservation.DeleteReservationGroupRequest, +): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = reservation.Reservation() - # 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 + # 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.delete_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_reservation_group(request) - # Convert return value to protobuf type - return_value = reservation.Reservation.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 = reservation.DeleteReservationGroupRequest() + 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 response is None - response = client.failover_reservation(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_delete_reservation_group_async_from_dict(): + await test_delete_reservation_group_async(request_type=dict) -def test_failover_reservation_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_delete_reservation_group_field_headers(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.failover_reservation._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_create_capacity_commitment_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 = ReservationServiceClient( - 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_capacity_commitment - 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 = reservation.DeleteReservationGroupRequest() - # 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_capacity_commitment - ] = mock_rpc + request.name = "name_value" - request = {} - client.create_capacity_commitment(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + call.return_value = None + client.delete_reservation_group(request) # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.create_capacity_commitment(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) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] -def test_create_capacity_commitment_rest_required_fields( - request_type=reservation.CreateCapacityCommitmentRequest, -): - transport_class = transports.ReservationServiceRestTransport - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) +@pytest.mark.asyncio +async def test_delete_reservation_group_field_headers_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - # verify fields with default values are dropped + # 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 = reservation.DeleteReservationGroupRequest() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_capacity_commitment._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + request.name = "name_value" - # 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.delete_reservation_group), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_reservation_group(request) - jsonified_request["parent"] = "parent_value" + # 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_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_capacity_commitment._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "capacity_commitment_id", - "enforce_single_admin_project_per_org", - ) - ) - jsonified_request.update(unset_fields) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" +def test_delete_reservation_group_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = reservation.CapacityCommitment() - # 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 + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__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_reservation_group( + name="name_value", + ) - # Convert return value to protobuf type - return_value = reservation.CapacityCommitment.pb(return_value) - json_return_value = json_format.MessageToJson(return_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 - response_value._content = json_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_capacity_commitment(request) +def test_delete_reservation_group_flattened_error(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_reservation_group( + reservation.DeleteReservationGroupRequest(), + name="name_value", + ) -def test_create_capacity_commitment_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_delete_reservation_group_flattened_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.create_capacity_commitment._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "capacityCommitmentId", - "enforceSingleAdminProjectPerOrg", - ) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.delete_reservation_group( + name="name_value", ) - & set(("parent",)) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_delete_reservation_group_flattened_error_async(): + client = ReservationServiceAsyncClient( + 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_reservation_group( + reservation.DeleteReservationGroupRequest(), + name="name_value", + ) + -def test_create_capacity_commitment_rest_flattened(): +@pytest.mark.parametrize( + "request_type", + [ + reservation.ListReservationGroupsRequest, + dict, + ], +) +def test_list_reservation_groups(request_type, transport: str = "grpc"): client = ReservationServiceClient( 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 = reservation.CapacityCommitment() - - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + # 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( - parent="parent_value", - capacity_commitment=reservation.CapacityCommitment(name="name_value"), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ListReservationGroupsResponse( + 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 = reservation.CapacityCommitment.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_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_reservation_groups(request) - client.create_capacity_commitment(**mock_args) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = reservation.ListReservationGroupsRequest() + 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/v1/{parent=projects/*/locations/*}/capacityCommitments" - % client.transport._host, - args[1], - ) + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListReservationGroupsPager) + assert response.next_page_token == "next_page_token_value" -def test_create_capacity_commitment_rest_flattened_error(transport: str = "rest"): +def test_list_reservation_groups_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 = ReservationServiceClient( 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.create_capacity_commitment( - reservation.CreateCapacityCommitmentRequest(), + # 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 = reservation.ListReservationGroupsRequest( + parent="parent_value", + page_token="page_token_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_reservation_groups(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == reservation.ListReservationGroupsRequest( parent="parent_value", - capacity_commitment=reservation.CapacityCommitment(name="name_value"), + page_token="page_token_value", ) -def test_list_capacity_commitments_rest_use_cached_wrapped_rpc(): +def test_list_reservation_groups_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -11222,7 +11966,7 @@ def test_list_capacity_commitments_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.list_capacity_commitments + client._transport.list_reservation_groups in client._transport._wrapped_methods ) @@ -11232,290 +11976,505 @@ def test_list_capacity_commitments_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_capacity_commitments + client._transport.list_reservation_groups ] = mock_rpc - request = {} - client.list_capacity_commitments(request) + client.list_reservation_groups(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_capacity_commitments(request) + client.list_reservation_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_list_capacity_commitments_rest_required_fields( - request_type=reservation.ListCapacityCommitmentsRequest, +@pytest.mark.asyncio +async def test_list_reservation_groups_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.ReservationServiceRestTransport + # Clients should use _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 = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) - ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # verify fields with default values are dropped + # Ensure method has been cached + assert ( + client._client._transport.list_reservation_groups + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_capacity_commitments._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.list_reservation_groups + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.list_reservation_groups(request) - jsonified_request["parent"] = "parent_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_capacity_commitments._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) + await client.list_reservation_groups(request) - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_list_reservation_groups_async( + transport: str = "grpc_asyncio", + request_type=reservation.ListReservationGroupsRequest, +): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = reservation.ListCapacityCommitmentsResponse() - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "get", - "query_params": pb_request, - } - transcode.return_value = transcode_result + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() - response_value = Response() - response_value.status_code = 200 + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListReservationGroupsResponse( + next_page_token="next_page_token_value", + ) + ) + response = await client.list_reservation_groups(request) - # Convert return value to protobuf type - return_value = reservation.ListCapacityCommitmentsResponse.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 = reservation.ListReservationGroupsRequest() + assert args[0] == request - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListReservationGroupsAsyncPager) + assert response.next_page_token == "next_page_token_value" - response = client.list_capacity_commitments(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params +@pytest.mark.asyncio +async def test_list_reservation_groups_async_from_dict(): + await test_list_reservation_groups_async(request_type=dict) -def test_list_capacity_commitments_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_list_reservation_groups_field_headers(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.list_capacity_commitments._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = reservation.ListReservationGroupsRequest() + request.parent = "parent_value" -def test_list_capacity_commitments_rest_flattened(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + call.return_value = reservation.ListReservationGroupsResponse() + client.list_reservation_groups(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_reservation_groups_field_headers_async(): + client = ReservationServiceAsyncClient( + 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 = reservation.ListReservationGroupsRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListReservationGroupsResponse() + ) + await client.list_reservation_groups(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_list_reservation_groups_flattened(): client = ReservationServiceClient( 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 = reservation.ListCapacityCommitmentsResponse() + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ListReservationGroupsResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_reservation_groups( + parent="parent_value", + ) - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val - # get truthy value for each flattened field - mock_args = dict( + +def test_list_reservation_groups_flattened_error(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_reservation_groups( + reservation.ListReservationGroupsRequest(), 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 = reservation.ListCapacityCommitmentsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_capacity_commitments(**mock_args) +@pytest.mark.asyncio +async def test_list_reservation_groups_flattened_async(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = reservation.ListReservationGroupsResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListReservationGroupsResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_reservation_groups( + parent="parent_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}/capacityCommitments" - % client.transport._host, - args[1], - ) + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val -def test_list_capacity_commitments_rest_flattened_error(transport: str = "rest"): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, +@pytest.mark.asyncio +async def test_list_reservation_groups_flattened_error_async(): + client = ReservationServiceAsyncClient( + 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.list_capacity_commitments( - reservation.ListCapacityCommitmentsRequest(), + await client.list_reservation_groups( + reservation.ListReservationGroupsRequest(), parent="parent_value", ) -def test_list_capacity_commitments_rest_pager(transport: str = "rest"): +def test_list_reservation_groups_pager(transport_name: str = "grpc"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport=transport_name, ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - reservation.ListCapacityCommitmentsResponse( - capacity_commitments=[ - reservation.CapacityCommitment(), - reservation.CapacityCommitment(), - reservation.CapacityCommitment(), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + reservation.ReservationGroup(), ], next_page_token="abc", ), - reservation.ListCapacityCommitmentsResponse( - capacity_commitments=[], + reservation.ListReservationGroupsResponse( + reservation_groups=[], next_page_token="def", ), - reservation.ListCapacityCommitmentsResponse( - capacity_commitments=[ - reservation.CapacityCommitment(), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), ], next_page_token="ghi", ), - reservation.ListCapacityCommitmentsResponse( - capacity_commitments=[ - reservation.CapacityCommitment(), - reservation.CapacityCommitment(), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), ], ), + RuntimeError, ) - # Two responses for two calls - response = response + response - # Wrap the values into proper Response objs - response = tuple( - reservation.ListCapacityCommitmentsResponse.to_json(x) for x in response + expected_metadata = () + retry = retries.Retry() + timeout = 5 + expected_metadata = tuple(expected_metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), ) - 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 + pager = client.list_reservation_groups(request={}, retry=retry, timeout=timeout) - sample_request = {"parent": "projects/sample1/locations/sample2"} - - pager = client.list_capacity_commitments(request=sample_request) + assert pager._metadata == expected_metadata + assert pager._retry == retry + assert pager._timeout == timeout results = list(pager) assert len(results) == 6 - assert all(isinstance(i, reservation.CapacityCommitment) for i in results) + assert all(isinstance(i, reservation.ReservationGroup) for i in results) - pages = list(client.list_capacity_commitments(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +def test_list_reservation_groups_pages(transport_name: str = "grpc"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport_name, + ) -def test_get_capacity_commitment_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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + next_page_token="abc", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[], + next_page_token="def", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + ], + next_page_token="ghi", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + ), + RuntimeError, ) + pages = list(client.list_reservation_groups(request={}).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - # 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_capacity_commitment - in client._transport._wrapped_methods - ) +@pytest.mark.asyncio +async def test_list_reservation_groups_async_pager(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) - # 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.list_reservation_groups), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + next_page_token="abc", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[], + next_page_token="def", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + ], + next_page_token="ghi", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + ), + RuntimeError, ) - client._transport._wrapped_methods[ - client._transport.get_capacity_commitment - ] = mock_rpc + async_pager = await client.list_reservation_groups( + request={}, + ) + assert async_pager.next_page_token == "abc" + responses = [] + async for response in async_pager: # pragma: no branch + responses.append(response) - request = {} - client.get_capacity_commitment(request) + assert len(responses) == 6 + assert all(isinstance(i, reservation.ReservationGroup) for i in responses) + + +@pytest.mark.asyncio +async def test_list_reservation_groups_async_pages(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + next_page_token="abc", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[], + next_page_token="def", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + ], + next_page_token="ghi", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + ), + RuntimeError, + ) + pages = [] + # Workaround issue in python 3.9 related to code coverage by adding `# pragma: no branch` + # See https://github.com/googleapis/gapic-generator-python/pull/1174#issuecomment-1025132372 + async for page_ in ( # pragma: no branch + await client.list_reservation_groups(request={}) + ).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_create_reservation_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 = ReservationServiceClient( + 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_reservation 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_reservation + ] = mock_rpc + + request = {} + client.create_reservation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_capacity_commitment(request) + client.create_reservation(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_capacity_commitment_rest_required_fields( - request_type=reservation.GetCapacityCommitmentRequest, +def test_create_reservation_rest_required_fields( + request_type=gcbr_reservation.CreateReservationRequest, ): transport_class = transports.ReservationServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -11526,21 +12485,23 @@ def test_get_capacity_commitment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_capacity_commitment._get_unset_required_fields(jsonified_request) + ).create_reservation._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_capacity_commitment._get_unset_required_fields(jsonified_request) + ).create_reservation._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("reservation_id",)) 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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11549,7 +12510,7 @@ def test_get_capacity_commitment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.CapacityCommitment() + return_value = gcbr_reservation.Reservation() # 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 @@ -11561,39 +12522,40 @@ def test_get_capacity_commitment_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 = reservation.CapacityCommitment.pb(return_value) + return_value = gcbr_reservation.Reservation.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_capacity_commitment(request) + response = client.create_reservation(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_capacity_commitment_rest_unset_required_fields(): +def test_create_reservation_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_capacity_commitment._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_reservation._get_unset_required_fields({}) + assert set(unset_fields) == (set(("reservationId",)) & set(("parent",))) -def test_get_capacity_commitment_rest_flattened(): +def test_create_reservation_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -11602,16 +12564,16 @@ def test_get_capacity_commitment_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 = reservation.CapacityCommitment() + return_value = gcbr_reservation.Reservation() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } + sample_request = {"parent": "projects/sample1/locations/sample2"} # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + reservation=gcbr_reservation.Reservation(name="name_value"), + reservation_id="reservation_id_value", ) mock_args.update(sample_request) @@ -11619,26 +12581,26 @@ def test_get_capacity_commitment_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.CapacityCommitment.pb(return_value) + return_value = gcbr_reservation.Reservation.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_capacity_commitment(**mock_args) + client.create_reservation(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/capacityCommitments/*}" + "%s/v1/{parent=projects/*/locations/*}/reservations" % client.transport._host, args[1], ) -def test_get_capacity_commitment_rest_flattened_error(transport: str = "rest"): +def test_create_reservation_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -11647,13 +12609,15 @@ def test_get_capacity_commitment_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_capacity_commitment( - reservation.GetCapacityCommitmentRequest(), - name="name_value", + client.create_reservation( + gcbr_reservation.CreateReservationRequest(), + parent="parent_value", + reservation=gcbr_reservation.Reservation(name="name_value"), + reservation_id="reservation_id_value", ) -def test_delete_capacity_commitment_rest_use_cached_wrapped_rpc(): +def test_list_reservations_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: @@ -11667,10 +12631,7 @@ def test_delete_capacity_commitment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_capacity_commitment - in client._transport._wrapped_methods - ) + assert client._transport.list_reservations in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -11678,29 +12639,29 @@ def test_delete_capacity_commitment_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_capacity_commitment + client._transport.list_reservations ] = mock_rpc request = {} - client.delete_capacity_commitment(request) + client.list_reservations(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_capacity_commitment(request) + client.list_reservations(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_capacity_commitment_rest_required_fields( - request_type=reservation.DeleteCapacityCommitmentRequest, +def test_list_reservations_rest_required_fields( + request_type=reservation.ListReservationsRequest, ): transport_class = transports.ReservationServiceRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -11711,23 +12672,28 @@ def test_delete_capacity_commitment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_capacity_commitment._get_unset_required_fields(jsonified_request) + ).list_reservations._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_capacity_commitment._get_unset_required_fields(jsonified_request) + ).list_reservations._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("force",)) + 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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11736,7 +12702,7 @@ def test_delete_capacity_commitment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = reservation.ListReservationsResponse() # 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 @@ -11748,36 +12714,47 @@ def test_delete_capacity_commitment_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 = reservation.ListReservationsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_capacity_commitment(request) + response = client.list_reservations(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_capacity_commitment_rest_unset_required_fields(): +def test_list_reservations_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_capacity_commitment._get_unset_required_fields({}) - assert set(unset_fields) == (set(("force",)) & set(("name",))) + unset_fields = transport.list_reservations._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_delete_capacity_commitment_rest_flattened(): +def test_list_reservations_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -11786,41 +12763,41 @@ def test_delete_capacity_commitment_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 = reservation.ListReservationsResponse() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } + sample_request = {"parent": "projects/sample1/locations/sample2"} # 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 = reservation.ListReservationsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._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_capacity_commitment(**mock_args) + client.list_reservations(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/capacityCommitments/*}" + "%s/v1/{parent=projects/*/locations/*}/reservations" % client.transport._host, args[1], ) -def test_delete_capacity_commitment_rest_flattened_error(transport: str = "rest"): +def test_list_reservations_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -11829,118 +12806,76 @@ def test_delete_capacity_commitment_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_capacity_commitment( - reservation.DeleteCapacityCommitmentRequest(), - name="name_value", - ) - - -def test_update_capacity_commitment_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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() - - # Ensure method has been cached - assert ( - client._transport.update_capacity_commitment - 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.list_reservations( + reservation.ListReservationsRequest(), + parent="parent_value", ) - client._transport._wrapped_methods[ - client._transport.update_capacity_commitment - ] = mock_rpc - - request = {} - client.update_capacity_commitment(request) - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - client.update_capacity_commitment(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_capacity_commitment_rest_flattened(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_list_reservations_rest_pager(transport: str = "rest"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + 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 = reservation.CapacityCommitment() - - # get arguments that satisfy an http rule for this method - sample_request = { - "capacity_commitment": { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } - } - - # get truthy value for each flattened field - mock_args = dict( - capacity_commitment=reservation.CapacityCommitment(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_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 = ( + reservation.ListReservationsResponse( + reservations=[ + reservation.Reservation(), + reservation.Reservation(), + reservation.Reservation(), + ], + next_page_token="abc", + ), + reservation.ListReservationsResponse( + reservations=[], + next_page_token="def", + ), + reservation.ListReservationsResponse( + reservations=[ + reservation.Reservation(), + ], + next_page_token="ghi", + ), + reservation.ListReservationsResponse( + reservations=[ + reservation.Reservation(), + reservation.Reservation(), + ], + ), ) - 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 = reservation.CapacityCommitment.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_capacity_commitment(**mock_args) + # Two responses for two calls + response = response + response - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{capacity_commitment.name=projects/*/locations/*/capacityCommitments/*}" - % client.transport._host, - args[1], + # Wrap the values into proper Response objs + response = tuple( + reservation.ListReservationsResponse.to_json(x) for x in response ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + sample_request = {"parent": "projects/sample1/locations/sample2"} -def test_update_capacity_commitment_rest_flattened_error(transport: str = "rest"): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) + pager = client.list_reservations(request=sample_request) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.update_capacity_commitment( - reservation.UpdateCapacityCommitmentRequest(), - capacity_commitment=reservation.CapacityCommitment(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), - ) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, reservation.Reservation) for i in results) + pages = list(client.list_reservations(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token -def test_split_capacity_commitment_rest_use_cached_wrapped_rpc(): + +def test_get_reservation_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: @@ -11954,35 +12889,30 @@ def test_split_capacity_commitment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.split_capacity_commitment - in client._transport._wrapped_methods - ) + assert client._transport.get_reservation 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.split_capacity_commitment - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_reservation] = mock_rpc request = {} - client.split_capacity_commitment(request) + client.get_reservation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.split_capacity_commitment(request) + client.get_reservation(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_split_capacity_commitment_rest_required_fields( - request_type=reservation.SplitCapacityCommitmentRequest, +def test_get_reservation_rest_required_fields( + request_type=reservation.GetReservationRequest, ): transport_class = transports.ReservationServiceRestTransport @@ -11998,7 +12928,7 @@ def test_split_capacity_commitment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).split_capacity_commitment._get_unset_required_fields(jsonified_request) + ).get_reservation._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12007,7 +12937,7 @@ def test_split_capacity_commitment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).split_capacity_commitment._get_unset_required_fields(jsonified_request) + ).get_reservation._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -12021,7 +12951,7 @@ def test_split_capacity_commitment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.SplitCapacityCommitmentResponse() + return_value = reservation.Reservation() # 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 @@ -12033,40 +12963,39 @@ def test_split_capacity_commitment_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 = reservation.SplitCapacityCommitmentResponse.pb(return_value) + return_value = reservation.Reservation.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.split_capacity_commitment(request) + response = client.get_reservation(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_split_capacity_commitment_rest_unset_required_fields(): +def test_get_reservation_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.split_capacity_commitment._get_unset_required_fields({}) + unset_fields = transport.get_reservation._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_split_capacity_commitment_rest_flattened(): +def test_get_reservation_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12075,17 +13004,16 @@ def test_split_capacity_commitment_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 = reservation.SplitCapacityCommitmentResponse() + return_value = reservation.Reservation() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + "name": "projects/sample1/locations/sample2/reservations/sample3" } # get truthy value for each flattened field mock_args = dict( name="name_value", - slot_count=1098, ) mock_args.update(sample_request) @@ -12093,26 +13021,26 @@ def test_split_capacity_commitment_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.SplitCapacityCommitmentResponse.pb(return_value) + return_value = reservation.Reservation.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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.split_capacity_commitment(**mock_args) + client.get_reservation(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/capacityCommitments/*}:split" + "%s/v1/{name=projects/*/locations/*/reservations/*}" % client.transport._host, args[1], ) -def test_split_capacity_commitment_rest_flattened_error(transport: str = "rest"): +def test_get_reservation_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12121,14 +13049,13 @@ def test_split_capacity_commitment_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.split_capacity_commitment( - reservation.SplitCapacityCommitmentRequest(), + client.get_reservation( + reservation.GetReservationRequest(), name="name_value", - slot_count=1098, ) -def test_merge_capacity_commitments_rest_use_cached_wrapped_rpc(): +def test_delete_reservation_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: @@ -12143,8 +13070,7 @@ def test_merge_capacity_commitments_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.merge_capacity_commitments - in client._transport._wrapped_methods + client._transport.delete_reservation in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -12153,163 +13079,63 @@ def test_merge_capacity_commitments_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.merge_capacity_commitments + client._transport.delete_reservation ] = mock_rpc request = {} - client.merge_capacity_commitments(request) + client.delete_reservation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.merge_capacity_commitments(request) + client.delete_reservation(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_merge_capacity_commitments_rest_flattened(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_delete_reservation_rest_required_fields( + request_type=reservation.DeleteReservationRequest, +): + transport_class = transports.ReservationServiceRestTransport - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = reservation.CapacityCommitment() + 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) + ) - # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + # verify fields with default values are dropped - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - capacity_commitment_ids=["capacity_commitment_ids_value"], - ) - mock_args.update(sample_request) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_reservation._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = reservation.CapacityCommitment.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # verify required fields with default values are now present - client.merge_capacity_commitments(**mock_args) + jsonified_request["name"] = "name_value" - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}/capacityCommitments:merge" - % client.transport._host, - args[1], - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_reservation._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_merge_capacity_commitments_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="rest", ) - - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.merge_capacity_commitments( - reservation.MergeCapacityCommitmentsRequest(), - parent="parent_value", - capacity_commitment_ids=["capacity_commitment_ids_value"], - ) - - -def test_create_assignment_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 = ReservationServiceClient( - 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_assignment 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_assignment - ] = mock_rpc - - request = {} - client.create_assignment(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.create_assignment(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_assignment_rest_required_fields( - request_type=reservation.CreateAssignmentRequest, -): - transport_class = transports.ReservationServiceRestTransport - - 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_assignment._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_assignment._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("assignment_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" - - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.Assignment() + 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 @@ -12321,40 +13147,36 @@ def test_create_assignment_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 = reservation.Assignment.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_assignment(request) + response = client.delete_reservation(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_assignment_rest_unset_required_fields(): +def test_delete_reservation_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_assignment._get_unset_required_fields({}) - assert set(unset_fields) == (set(("assignmentId",)) & set(("parent",))) + unset_fields = transport.delete_reservation._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_create_assignment_rest_flattened(): +def test_delete_reservation_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12363,44 +13185,41 @@ def test_create_assignment_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 = reservation.Assignment() + return_value = None # get arguments that satisfy an http rule for this method sample_request = { - "parent": "projects/sample1/locations/sample2/reservations/sample3" + "name": "projects/sample1/locations/sample2/reservations/sample3" } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - assignment=reservation.Assignment(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 = reservation.Assignment.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_assignment(**mock_args) + client.delete_reservation(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*/reservations/*}/assignments" + "%s/v1/{name=projects/*/locations/*/reservations/*}" % client.transport._host, args[1], ) -def test_create_assignment_rest_flattened_error(transport: str = "rest"): +def test_delete_reservation_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12409,14 +13228,13 @@ def test_create_assignment_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_assignment( - reservation.CreateAssignmentRequest(), - parent="parent_value", - assignment=reservation.Assignment(name="name_value"), + client.delete_reservation( + reservation.DeleteReservationRequest(), + name="name_value", ) -def test_list_assignments_rest_use_cached_wrapped_rpc(): +def test_update_reservation_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: @@ -12430,7 +13248,9 @@ def test_list_assignments_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_assignments in client._transport._wrapped_methods + assert ( + client._transport.update_reservation in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -12438,122 +13258,23 @@ def test_list_assignments_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_assignments + client._transport.update_reservation ] = mock_rpc request = {} - client.list_assignments(request) + client.update_reservation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_assignments(request) + client.update_reservation(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_assignments_rest_required_fields( - request_type=reservation.ListAssignmentsRequest, -): - transport_class = transports.ReservationServiceRestTransport - - 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_assignments._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_assignments._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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = reservation.ListAssignmentsResponse() - # 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 = reservation.ListAssignmentsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_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_assignments(request) - - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params - - -def test_list_assignments_rest_unset_required_fields(): - transport = transports.ReservationServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - - unset_fields = transport.list_assignments._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) - - -def test_list_assignments_rest_flattened(): +def test_update_reservation_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12562,16 +13283,19 @@ def test_list_assignments_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 = reservation.ListAssignmentsResponse() + return_value = gcbr_reservation.Reservation() # get arguments that satisfy an http rule for this method sample_request = { - "parent": "projects/sample1/locations/sample2/reservations/sample3" + "reservation": { + "name": "projects/sample1/locations/sample2/reservations/sample3" + } } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + reservation=gcbr_reservation.Reservation(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -12579,26 +13303,26 @@ def test_list_assignments_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.ListAssignmentsResponse.pb(return_value) + return_value = gcbr_reservation.Reservation.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_assignments(**mock_args) + client.update_reservation(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*/reservations/*}/assignments" + "%s/v1/{reservation.name=projects/*/locations/*/reservations/*}" % client.transport._host, args[1], ) -def test_list_assignments_rest_flattened_error(transport: str = "rest"): +def test_update_reservation_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12607,78 +13331,14 @@ def test_list_assignments_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_assignments( - reservation.ListAssignmentsRequest(), - parent="parent_value", + client.update_reservation( + gcbr_reservation.UpdateReservationRequest(), + reservation=gcbr_reservation.Reservation(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_list_assignments_rest_pager(transport: str = "rest"): - client = ReservationServiceClient( - 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 = ( - reservation.ListAssignmentsResponse( - assignments=[ - reservation.Assignment(), - reservation.Assignment(), - reservation.Assignment(), - ], - next_page_token="abc", - ), - reservation.ListAssignmentsResponse( - assignments=[], - next_page_token="def", - ), - reservation.ListAssignmentsResponse( - assignments=[ - reservation.Assignment(), - ], - next_page_token="ghi", - ), - reservation.ListAssignmentsResponse( - assignments=[ - reservation.Assignment(), - reservation.Assignment(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - reservation.ListAssignmentsResponse.to_json(x) for x in response - ) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - - sample_request = { - "parent": "projects/sample1/locations/sample2/reservations/sample3" - } - - pager = client.list_assignments(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, reservation.Assignment) for i in results) - - pages = list(client.list_assignments(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_delete_assignment_rest_use_cached_wrapped_rpc(): +def test_failover_reservation_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: @@ -12692,7 +13352,9 @@ def test_delete_assignment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_assignment in client._transport._wrapped_methods + assert ( + client._transport.failover_reservation in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -12700,24 +13362,24 @@ def test_delete_assignment_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.delete_assignment + client._transport.failover_reservation ] = mock_rpc request = {} - client.delete_assignment(request) + client.failover_reservation(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_assignment(request) + client.failover_reservation(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_assignment_rest_required_fields( - request_type=reservation.DeleteAssignmentRequest, +def test_failover_reservation_rest_required_fields( + request_type=reservation.FailoverReservationRequest, ): transport_class = transports.ReservationServiceRestTransport @@ -12733,7 +13395,7 @@ def test_delete_assignment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_assignment._get_unset_required_fields(jsonified_request) + ).failover_reservation._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12742,7 +13404,7 @@ def test_delete_assignment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_assignment._get_unset_required_fields(jsonified_request) + ).failover_reservation._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -12756,7 +13418,7 @@ def test_delete_assignment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = reservation.Reservation() # 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 @@ -12768,94 +13430,40 @@ def test_delete_assignment_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 = reservation.Reservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_assignment(request) + response = client.failover_reservation(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_assignment_rest_unset_required_fields(): +def test_failover_reservation_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_assignment._get_unset_required_fields({}) + unset_fields = transport.failover_reservation._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_assignment_rest_flattened(): - client = ReservationServiceClient( - 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": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" - } - - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - 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_assignment(**mock_args) - - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/reservations/*/assignments/*}" - % client.transport._host, - args[1], - ) - - -def test_delete_assignment_rest_flattened_error(transport: str = "rest"): - client = ReservationServiceClient( - 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_assignment( - reservation.DeleteAssignmentRequest(), - name="name_value", - ) - - -def test_search_assignments_rest_use_cached_wrapped_rpc(): +def test_create_capacity_commitment_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: @@ -12870,7 +13478,8 @@ def test_search_assignments_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.search_assignments in client._transport._wrapped_methods + client._transport.create_capacity_commitment + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -12879,24 +13488,24 @@ def test_search_assignments_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.search_assignments + client._transport.create_capacity_commitment ] = mock_rpc request = {} - client.search_assignments(request) + client.create_capacity_commitment(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.search_assignments(request) + client.create_capacity_commitment(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_assignments_rest_required_fields( - request_type=reservation.SearchAssignmentsRequest, +def test_create_capacity_commitment_rest_required_fields( + request_type=reservation.CreateCapacityCommitmentRequest, ): transport_class = transports.ReservationServiceRestTransport @@ -12912,7 +13521,7 @@ def test_search_assignments_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).search_assignments._get_unset_required_fields(jsonified_request) + ).create_capacity_commitment._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12921,13 +13530,12 @@ def test_search_assignments_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).search_assignments._get_unset_required_fields(jsonified_request) + ).create_capacity_commitment._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", - "query", + "capacity_commitment_id", + "enforce_single_admin_project_per_org", ) ) jsonified_request.update(unset_fields) @@ -12943,7 +13551,7 @@ def test_search_assignments_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.SearchAssignmentsResponse() + return_value = reservation.CapacityCommitment() # 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 @@ -12955,48 +13563,48 @@ def test_search_assignments_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 = reservation.SearchAssignmentsResponse.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_assignments(request) + response = client.create_capacity_commitment(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_search_assignments_rest_unset_required_fields(): +def test_create_capacity_commitment_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.search_assignments._get_unset_required_fields({}) + unset_fields = transport.create_capacity_commitment._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( - "pageSize", - "pageToken", - "query", + "capacityCommitmentId", + "enforceSingleAdminProjectPerOrg", ) ) & set(("parent",)) ) -def test_search_assignments_rest_flattened(): +def test_create_capacity_commitment_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13005,7 +13613,7 @@ def test_search_assignments_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 = reservation.SearchAssignmentsResponse() + return_value = reservation.CapacityCommitment() # get arguments that satisfy an http rule for this method sample_request = {"parent": "projects/sample1/locations/sample2"} @@ -13013,7 +13621,7 @@ def test_search_assignments_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", - query="query_value", + capacity_commitment=reservation.CapacityCommitment(name="name_value"), ) mock_args.update(sample_request) @@ -13021,26 +13629,26 @@ def test_search_assignments_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.SearchAssignmentsResponse.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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.search_assignments(**mock_args) + client.create_capacity_commitment(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}:searchAssignments" + "%s/v1/{parent=projects/*/locations/*}/capacityCommitments" % client.transport._host, args[1], ) -def test_search_assignments_rest_flattened_error(transport: str = "rest"): +def test_create_capacity_commitment_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13049,84 +13657,21 @@ def test_search_assignments_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.search_assignments( - reservation.SearchAssignmentsRequest(), + client.create_capacity_commitment( + reservation.CreateCapacityCommitmentRequest(), parent="parent_value", - query="query_value", + capacity_commitment=reservation.CapacityCommitment(name="name_value"), ) -def test_search_assignments_rest_pager(transport: str = "rest"): - client = ReservationServiceClient( - 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 = ( - reservation.SearchAssignmentsResponse( - assignments=[ - reservation.Assignment(), - reservation.Assignment(), - reservation.Assignment(), - ], - next_page_token="abc", - ), - reservation.SearchAssignmentsResponse( - assignments=[], - next_page_token="def", - ), - reservation.SearchAssignmentsResponse( - assignments=[ - reservation.Assignment(), - ], - next_page_token="ghi", - ), - reservation.SearchAssignmentsResponse( - assignments=[ - reservation.Assignment(), - reservation.Assignment(), - ], - ), - ) - # Two responses for two calls - response = response + response - - # Wrap the values into proper Response objs - response = tuple( - reservation.SearchAssignmentsResponse.to_json(x) for x in response - ) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - - sample_request = {"parent": "projects/sample1/locations/sample2"} - - pager = client.search_assignments(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, reservation.Assignment) for i in results) - - pages = list(client.search_assignments(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token - - -def test_search_all_assignments_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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) +def test_list_capacity_commitments_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) # Should wrap all calls on client creation assert wrapper_fn.call_count > 0 @@ -13134,7 +13679,7 @@ def test_search_all_assignments_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.search_all_assignments + client._transport.list_capacity_commitments in client._transport._wrapped_methods ) @@ -13144,24 +13689,24 @@ def test_search_all_assignments_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.search_all_assignments + client._transport.list_capacity_commitments ] = mock_rpc request = {} - client.search_all_assignments(request) + client.list_capacity_commitments(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.search_all_assignments(request) + client.list_capacity_commitments(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_all_assignments_rest_required_fields( - request_type=reservation.SearchAllAssignmentsRequest, +def test_list_capacity_commitments_rest_required_fields( + request_type=reservation.ListCapacityCommitmentsRequest, ): transport_class = transports.ReservationServiceRestTransport @@ -13177,7 +13722,7 @@ def test_search_all_assignments_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).search_all_assignments._get_unset_required_fields(jsonified_request) + ).list_capacity_commitments._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -13186,13 +13731,12 @@ def test_search_all_assignments_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).search_all_assignments._get_unset_required_fields(jsonified_request) + ).list_capacity_commitments._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", - "query", ) ) jsonified_request.update(unset_fields) @@ -13208,7 +13752,7 @@ def test_search_all_assignments_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.SearchAllAssignmentsResponse() + return_value = reservation.ListCapacityCommitmentsResponse() # 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 @@ -13229,39 +13773,38 @@ def test_search_all_assignments_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.SearchAllAssignmentsResponse.pb(return_value) + return_value = reservation.ListCapacityCommitmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_all_assignments(request) + response = client.list_capacity_commitments(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_search_all_assignments_rest_unset_required_fields(): +def test_list_capacity_commitments_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.search_all_assignments._get_unset_required_fields({}) + unset_fields = transport.list_capacity_commitments._get_unset_required_fields({}) assert set(unset_fields) == ( set( ( "pageSize", "pageToken", - "query", ) ) & set(("parent",)) ) -def test_search_all_assignments_rest_flattened(): +def test_list_capacity_commitments_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13270,7 +13813,7 @@ def test_search_all_assignments_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 = reservation.SearchAllAssignmentsResponse() + return_value = reservation.ListCapacityCommitmentsResponse() # get arguments that satisfy an http rule for this method sample_request = {"parent": "projects/sample1/locations/sample2"} @@ -13278,7 +13821,6 @@ def test_search_all_assignments_rest_flattened(): # get truthy value for each flattened field mock_args = dict( parent="parent_value", - query="query_value", ) mock_args.update(sample_request) @@ -13286,26 +13828,26 @@ def test_search_all_assignments_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.SearchAllAssignmentsResponse.pb(return_value) + return_value = reservation.ListCapacityCommitmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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.search_all_assignments(**mock_args) + client.list_capacity_commitments(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}:searchAllAssignments" + "%s/v1/{parent=projects/*/locations/*}/capacityCommitments" % client.transport._host, args[1], ) -def test_search_all_assignments_rest_flattened_error(transport: str = "rest"): +def test_list_capacity_commitments_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13314,14 +13856,13 @@ def test_search_all_assignments_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.search_all_assignments( - reservation.SearchAllAssignmentsRequest(), + client.list_capacity_commitments( + reservation.ListCapacityCommitmentsRequest(), parent="parent_value", - query="query_value", ) -def test_search_all_assignments_rest_pager(transport: str = "rest"): +def test_list_capacity_commitments_rest_pager(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13333,28 +13874,28 @@ def test_search_all_assignments_rest_pager(transport: str = "rest"): # with mock.patch.object(path_template, 'transcode') as transcode: # Set the response as a series of pages response = ( - reservation.SearchAllAssignmentsResponse( - assignments=[ - reservation.Assignment(), - reservation.Assignment(), - reservation.Assignment(), + reservation.ListCapacityCommitmentsResponse( + capacity_commitments=[ + reservation.CapacityCommitment(), + reservation.CapacityCommitment(), + reservation.CapacityCommitment(), ], next_page_token="abc", ), - reservation.SearchAllAssignmentsResponse( - assignments=[], + reservation.ListCapacityCommitmentsResponse( + capacity_commitments=[], next_page_token="def", ), - reservation.SearchAllAssignmentsResponse( - assignments=[ - reservation.Assignment(), + reservation.ListCapacityCommitmentsResponse( + capacity_commitments=[ + reservation.CapacityCommitment(), ], next_page_token="ghi", ), - reservation.SearchAllAssignmentsResponse( - assignments=[ - reservation.Assignment(), - reservation.Assignment(), + reservation.ListCapacityCommitmentsResponse( + capacity_commitments=[ + reservation.CapacityCommitment(), + reservation.CapacityCommitment(), ], ), ) @@ -13363,7 +13904,7 @@ def test_search_all_assignments_rest_pager(transport: str = "rest"): # Wrap the values into proper Response objs response = tuple( - reservation.SearchAllAssignmentsResponse.to_json(x) for x in response + reservation.ListCapacityCommitmentsResponse.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): @@ -13373,18 +13914,18 @@ def test_search_all_assignments_rest_pager(transport: str = "rest"): sample_request = {"parent": "projects/sample1/locations/sample2"} - pager = client.search_all_assignments(request=sample_request) + pager = client.list_capacity_commitments(request=sample_request) results = list(pager) assert len(results) == 6 - assert all(isinstance(i, reservation.Assignment) for i in results) + assert all(isinstance(i, reservation.CapacityCommitment) for i in results) - pages = list(client.search_all_assignments(request=sample_request).pages) + pages = list(client.list_capacity_commitments(request=sample_request).pages) for page_, token in zip(pages, ["abc", "def", "ghi", ""]): assert page_.raw_page.next_page_token == token -def test_move_assignment_rest_use_cached_wrapped_rpc(): +def test_get_capacity_commitment_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: @@ -13398,30 +13939,35 @@ def test_move_assignment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.move_assignment in client._transport._wrapped_methods + assert ( + client._transport.get_capacity_commitment + 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.move_assignment] = mock_rpc + client._transport._wrapped_methods[ + client._transport.get_capacity_commitment + ] = mock_rpc request = {} - client.move_assignment(request) + client.get_capacity_commitment(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.move_assignment(request) + client.get_capacity_commitment(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_move_assignment_rest_required_fields( - request_type=reservation.MoveAssignmentRequest, +def test_get_capacity_commitment_rest_required_fields( + request_type=reservation.GetCapacityCommitmentRequest, ): transport_class = transports.ReservationServiceRestTransport @@ -13437,7 +13983,7 @@ def test_move_assignment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).move_assignment._get_unset_required_fields(jsonified_request) + ).get_capacity_commitment._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -13446,7 +13992,7 @@ def test_move_assignment_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).move_assignment._get_unset_required_fields(jsonified_request) + ).get_capacity_commitment._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -13460,7 +14006,7 @@ def test_move_assignment_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.Assignment() + return_value = reservation.CapacityCommitment() # 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 @@ -13472,40 +14018,39 @@ def test_move_assignment_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 = reservation.Assignment.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.move_assignment(request) + response = client.get_capacity_commitment(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_move_assignment_rest_unset_required_fields(): +def test_get_capacity_commitment_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.move_assignment._get_unset_required_fields({}) + unset_fields = transport.get_capacity_commitment._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_move_assignment_rest_flattened(): +def test_get_capacity_commitment_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13514,17 +14059,16 @@ def test_move_assignment_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 = reservation.Assignment() + return_value = reservation.CapacityCommitment() # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" } # get truthy value for each flattened field mock_args = dict( name="name_value", - destination_id="destination_id_value", ) mock_args.update(sample_request) @@ -13532,26 +14076,26 @@ def test_move_assignment_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.Assignment.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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.move_assignment(**mock_args) + client.get_capacity_commitment(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/reservations/*/assignments/*}:move" + "%s/v1/{name=projects/*/locations/*/capacityCommitments/*}" % client.transport._host, args[1], ) -def test_move_assignment_rest_flattened_error(transport: str = "rest"): +def test_get_capacity_commitment_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13560,14 +14104,13 @@ def test_move_assignment_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.move_assignment( - reservation.MoveAssignmentRequest(), + client.get_capacity_commitment( + reservation.GetCapacityCommitmentRequest(), name="name_value", - destination_id="destination_id_value", ) -def test_update_assignment_rest_use_cached_wrapped_rpc(): +def test_delete_capacity_commitment_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: @@ -13581,7 +14124,10 @@ def test_update_assignment_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_assignment in client._transport._wrapped_methods + assert ( + client._transport.delete_capacity_commitment + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -13589,43 +14135,225 @@ def test_update_assignment_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_assignment + client._transport.delete_capacity_commitment ] = mock_rpc request = {} - client.update_assignment(request) + client.delete_capacity_commitment(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_assignment(request) + client.delete_capacity_commitment(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_assignment_rest_flattened(): +def test_delete_capacity_commitment_rest_required_fields( + request_type=reservation.DeleteCapacityCommitmentRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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_capacity_commitment._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_capacity_commitment._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("force",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + client = ReservationServiceClient( 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 = reservation.Assignment() - - # get arguments that satisfy an http rule for this method - sample_request = { - "assignment": { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + 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_capacity_commitment(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_capacity_commitment_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_capacity_commitment._get_unset_required_fields({}) + assert set(unset_fields) == (set(("force",)) & set(("name",))) + + +def test_delete_capacity_commitment_rest_flattened(): + client = ReservationServiceClient( + 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": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } # get truthy value for each flattened field mock_args = dict( - assignment=reservation.Assignment(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 + 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_capacity_commitment(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/capacityCommitments/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_capacity_commitment_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_capacity_commitment( + reservation.DeleteCapacityCommitmentRequest(), + name="name_value", + ) + + +def test_update_capacity_commitment_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.update_capacity_commitment + 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_capacity_commitment + ] = mock_rpc + + request = {} + client.update_capacity_commitment(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.update_capacity_commitment(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_capacity_commitment_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.CapacityCommitment() + + # get arguments that satisfy an http rule for this method + sample_request = { + "capacity_commitment": { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } + } + + # get truthy value for each flattened field + mock_args = dict( + capacity_commitment=reservation.CapacityCommitment(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -13634,26 +14362,26 @@ def test_update_assignment_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.Assignment.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_assignment(**mock_args) + client.update_capacity_commitment(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{assignment.name=projects/*/locations/*/reservations/*/assignments/*}" + "%s/v1/{capacity_commitment.name=projects/*/locations/*/capacityCommitments/*}" % client.transport._host, args[1], ) -def test_update_assignment_rest_flattened_error(transport: str = "rest"): +def test_update_capacity_commitment_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13662,14 +14390,14 @@ def test_update_assignment_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_assignment( - reservation.UpdateAssignmentRequest(), - assignment=reservation.Assignment(name="name_value"), + client.update_capacity_commitment( + reservation.UpdateCapacityCommitmentRequest(), + capacity_commitment=reservation.CapacityCommitment(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_bi_reservation_rest_use_cached_wrapped_rpc(): +def test_split_capacity_commitment_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: @@ -13684,7 +14412,8 @@ def test_get_bi_reservation_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_bi_reservation in client._transport._wrapped_methods + client._transport.split_capacity_commitment + in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -13693,24 +14422,24 @@ def test_get_bi_reservation_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_bi_reservation + client._transport.split_capacity_commitment ] = mock_rpc request = {} - client.get_bi_reservation(request) + client.split_capacity_commitment(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_bi_reservation(request) + client.split_capacity_commitment(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_bi_reservation_rest_required_fields( - request_type=reservation.GetBiReservationRequest, +def test_split_capacity_commitment_rest_required_fields( + request_type=reservation.SplitCapacityCommitmentRequest, ): transport_class = transports.ReservationServiceRestTransport @@ -13726,7 +14455,7 @@ def test_get_bi_reservation_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_bi_reservation._get_unset_required_fields(jsonified_request) + ).split_capacity_commitment._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -13735,7 +14464,7 @@ def test_get_bi_reservation_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_bi_reservation._get_unset_required_fields(jsonified_request) + ).split_capacity_commitment._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -13749,7 +14478,7 @@ def test_get_bi_reservation_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = reservation.BiReservation() + return_value = reservation.SplitCapacityCommitmentResponse() # 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 @@ -13761,39 +14490,40 @@ def test_get_bi_reservation_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 = reservation.BiReservation.pb(return_value) + return_value = reservation.SplitCapacityCommitmentResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_bi_reservation(request) + response = client.split_capacity_commitment(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_bi_reservation_rest_unset_required_fields(): +def test_split_capacity_commitment_rest_unset_required_fields(): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_bi_reservation._get_unset_required_fields({}) + unset_fields = transport.split_capacity_commitment._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_bi_reservation_rest_flattened(): +def test_split_capacity_commitment_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13802,14 +14532,17 @@ def test_get_bi_reservation_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 = reservation.BiReservation() + return_value = reservation.SplitCapacityCommitmentResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/locations/sample2/biReservation"} + sample_request = { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } # get truthy value for each flattened field mock_args = dict( name="name_value", + slot_count=1098, ) mock_args.update(sample_request) @@ -13817,26 +14550,26 @@ def test_get_bi_reservation_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.BiReservation.pb(return_value) + return_value = reservation.SplitCapacityCommitmentResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_bi_reservation(**mock_args) + client.split_capacity_commitment(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{name=projects/*/locations/*/biReservation}" + "%s/v1/{name=projects/*/locations/*/capacityCommitments/*}:split" % client.transport._host, args[1], ) -def test_get_bi_reservation_rest_flattened_error(transport: str = "rest"): +def test_split_capacity_commitment_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13845,13 +14578,14 @@ def test_get_bi_reservation_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_bi_reservation( - reservation.GetBiReservationRequest(), + client.split_capacity_commitment( + reservation.SplitCapacityCommitmentRequest(), name="name_value", + slot_count=1098, ) -def test_update_bi_reservation_rest_use_cached_wrapped_rpc(): +def test_merge_capacity_commitments_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: @@ -13866,7 +14600,7 @@ def test_update_bi_reservation_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_bi_reservation + client._transport.merge_capacity_commitments in client._transport._wrapped_methods ) @@ -13876,23 +14610,23 @@ def test_update_bi_reservation_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_bi_reservation + client._transport.merge_capacity_commitments ] = mock_rpc request = {} - client.update_bi_reservation(request) + client.merge_capacity_commitments(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_bi_reservation(request) + client.merge_capacity_commitments(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_bi_reservation_rest_flattened(): +def test_merge_capacity_commitments_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13901,19 +14635,15 @@ def test_update_bi_reservation_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 = reservation.BiReservation() + return_value = reservation.CapacityCommitment() # get arguments that satisfy an http rule for this method - sample_request = { - "bi_reservation": { - "name": "projects/sample1/locations/sample2/biReservation" - } - } + sample_request = {"parent": "projects/sample1/locations/sample2"} # get truthy value for each flattened field mock_args = dict( - bi_reservation=reservation.BiReservation(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + parent="parent_value", + capacity_commitment_ids=["capacity_commitment_ids_value"], ) mock_args.update(sample_request) @@ -13921,26 +14651,26 @@ def test_update_bi_reservation_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.BiReservation.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_bi_reservation(**mock_args) + client.merge_capacity_commitments(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{bi_reservation.name=projects/*/locations/*/biReservation}" + "%s/v1/{parent=projects/*/locations/*}/capacityCommitments:merge" % client.transport._host, args[1], ) -def test_update_bi_reservation_rest_flattened_error(transport: str = "rest"): +def test_merge_capacity_commitments_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13949,1220 +14679,4417 @@ def test_update_bi_reservation_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_bi_reservation( - reservation.UpdateBiReservationRequest(), - bi_reservation=reservation.BiReservation(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.merge_capacity_commitments( + reservation.MergeCapacityCommitmentsRequest(), + parent="parent_value", + capacity_commitment_ids=["capacity_commitment_ids_value"], ) -def test_credentials_transport_error(): - # It is an error to provide credentials and a transport instance. - transport = transports.ReservationServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): +def test_create_assignment_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 = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) - - # It is an error to provide a credentials file and a transport instance. - transport = transports.ReservationServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = ReservationServiceClient( - client_options={"credentials_file": "credentials.json"}, - transport=transport, + transport="rest", ) - # It is an error to provide an api_key and a transport instance. - transport = transports.ReservationServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - options = client_options.ClientOptions() - options.api_key = "api_key" - with pytest.raises(ValueError): - client = ReservationServiceClient( - client_options=options, - transport=transport, - ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # 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 = ReservationServiceClient( - client_options=options, credentials=ga_credentials.AnonymousCredentials() - ) + # Ensure method has been cached + assert client._transport.create_assignment in client._transport._wrapped_methods - # It is an error to provide scopes and a transport instance. - transport = transports.ReservationServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = ReservationServiceClient( - 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.create_assignment + ] = mock_rpc + request = {} + client.create_assignment(request) -def test_transport_instance(): - # A client may be instantiated with a custom transport instance. - transport = transports.ReservationServiceGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - client = ReservationServiceClient(transport=transport) - assert client.transport is transport + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.create_assignment(request) -def test_transport_get_channel(): - # A client may be instantiated with a custom transport instance. - transport = transports.ReservationServiceGrpcTransport( - 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.ReservationServiceGrpcAsyncIOTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - channel = transport.grpc_channel - assert channel +def test_create_assignment_rest_required_fields( + request_type=reservation.CreateAssignmentRequest, +): + transport_class = transports.ReservationServiceRestTransport -@pytest.mark.parametrize( - "transport_class", - [ - transports.ReservationServiceGrpcTransport, - transports.ReservationServiceGrpcAsyncIOTransport, - transports.ReservationServiceRestTransport, - ], -) -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_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 -def test_transport_kind_grpc(): - transport = ReservationServiceClient.get_transport_class("grpc")( + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ) - assert transport.kind == "grpc" + ).create_assignment._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 = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc" - ) - assert client is not None + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_assignment._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("assignment_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" -# 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_reservation_empty_call_grpc(): client = ReservationServiceClient( 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_reservation), "__call__" - ) as call: - call.return_value = gcbr_reservation.Reservation() - client.create_reservation(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = gcbr_reservation.CreateReservationRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = reservation.Assignment() + # 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_list_reservations_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = reservation.Assignment.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_reservations), "__call__" - ) as call: - call.return_value = reservation.ListReservationsResponse() - client.list_reservations(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 = reservation.ListReservationsRequest() + response = client.create_assignment(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_reservation_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_create_assignment_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_reservation), "__call__") as call: - call.return_value = reservation.Reservation() - client.get_reservation(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.GetReservationRequest() - - assert args[0] == request_msg + unset_fields = transport.create_assignment._get_unset_required_fields({}) + assert set(unset_fields) == (set(("assignmentId",)) & 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_reservation_empty_call_grpc(): +def test_create_assignment_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_reservation), "__call__" - ) as call: - call.return_value = None - client.delete_reservation(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.DeleteReservationRequest() + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = reservation.Assignment() - assert args[0] == request_msg + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/reservations/sample3" + } + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + assignment=reservation.Assignment(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_update_reservation_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) - - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_reservation), "__call__" - ) as call: - call.return_value = gcbr_reservation.Reservation() - client.update_reservation(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 = reservation.Assignment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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 = gcbr_reservation.UpdateReservationRequest() + client.create_assignment(**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/v1/{parent=projects/*/locations/*/reservations/*}/assignments" + % 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_failover_reservation_empty_call_grpc(): +def test_create_assignment_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.failover_reservation), "__call__" - ) as call: - call.return_value = reservation.Reservation() - client.failover_reservation(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_assignment( + reservation.CreateAssignmentRequest(), + parent="parent_value", + assignment=reservation.Assignment(name="name_value"), + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.FailoverReservationRequest() - assert args[0] == request_msg +def test_list_assignments_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 = ReservationServiceClient( + 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_capacity_commitment_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert client._transport.list_assignments in client._transport._wrapped_methods - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_capacity_commitment), "__call__" - ) as call: - call.return_value = reservation.CapacityCommitment() - client.create_capacity_commitment(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_assignments + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.CreateCapacityCommitmentRequest() + request = {} + client.list_assignments(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.list_assignments(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_capacity_commitments_empty_call_grpc(): - client = ReservationServiceClient( - 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_list_assignments_rest_required_fields( + request_type=reservation.ListAssignmentsRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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.list_capacity_commitments), "__call__" - ) as call: - call.return_value = reservation.ListCapacityCommitmentsResponse() - client.list_capacity_commitments(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 = reservation.ListCapacityCommitmentsRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_assignments._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() + ).list_assignments._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_get_capacity_commitment_empty_call_grpc(): client = ReservationServiceClient( 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_capacity_commitment), "__call__" - ) as call: - call.return_value = reservation.CapacityCommitment() - client.get_capacity_commitment(request=None) + # Designate an appropriate value for the returned response. + return_value = reservation.ListAssignmentsResponse() + # 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 = reservation.GetCapacityCommitmentRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = reservation.ListAssignmentsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_capacity_commitment_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.list_assignments(request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_capacity_commitment), "__call__" - ) as call: - call.return_value = None - client.delete_capacity_commitment(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 = reservation.DeleteCapacityCommitmentRequest() - assert args[0] == request_msg +def test_list_assignments_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.list_assignments._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_update_capacity_commitment_empty_call_grpc(): + +def test_list_assignments_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_capacity_commitment), "__call__" - ) as call: - call.return_value = reservation.CapacityCommitment() - client.update_capacity_commitment(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 = reservation.ListAssignmentsResponse() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.UpdateCapacityCommitmentRequest() + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/reservations/sample3" + } - 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 = reservation.ListAssignmentsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_assignments(**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_split_capacity_commitment_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/v1/{parent=projects/*/locations/*/reservations/*}/assignments" + % client.transport._host, + args[1], + ) + + +def test_list_assignments_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.split_capacity_commitment), "__call__" - ) as call: - call.return_value = reservation.SplitCapacityCommitmentResponse() - client.split_capacity_commitment(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.SplitCapacityCommitmentRequest() - - 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_assignments( + reservation.ListAssignmentsRequest(), + 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_merge_capacity_commitments_empty_call_grpc(): +def test_list_assignments_rest_pager(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.merge_capacity_commitments), "__call__" - ) as call: - call.return_value = reservation.CapacityCommitment() - client.merge_capacity_commitments(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 = ( + reservation.ListAssignmentsResponse( + assignments=[ + reservation.Assignment(), + reservation.Assignment(), + reservation.Assignment(), + ], + next_page_token="abc", + ), + reservation.ListAssignmentsResponse( + assignments=[], + next_page_token="def", + ), + reservation.ListAssignmentsResponse( + assignments=[ + reservation.Assignment(), + ], + next_page_token="ghi", + ), + reservation.ListAssignmentsResponse( + assignments=[ + reservation.Assignment(), + reservation.Assignment(), + ], + ), + ) + # 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 = reservation.MergeCapacityCommitmentsRequest() + # Wrap the values into proper Response objs + response = tuple( + reservation.ListAssignmentsResponse.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": "projects/sample1/locations/sample2/reservations/sample3" + } + pager = client.list_assignments(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_create_assignment_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, reservation.Assignment) for i in results) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_assignment), "__call__" - ) as call: - call.return_value = reservation.Assignment() - client.create_assignment(request=None) + pages = list(client.list_assignments(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 = reservation.CreateAssignmentRequest() - assert args[0] == request_msg +def test_delete_assignment_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 = ReservationServiceClient( + 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_assignments_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert client._transport.delete_assignment in client._transport._wrapped_methods - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_assignments), "__call__") as call: - call.return_value = reservation.ListAssignmentsResponse() - client.list_assignments(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_assignment + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.ListAssignmentsRequest() + request = {} + client.delete_assignment(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.delete_assignment(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_assignment_empty_call_grpc(): - client = ReservationServiceClient( - 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_assignment), "__call__" - ) as call: - call.return_value = None - client.delete_assignment(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.DeleteAssignmentRequest() +def test_delete_assignment_rest_required_fields( + request_type=reservation.DeleteAssignmentRequest, +): + transport_class = transports.ReservationServiceRestTransport - 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_search_assignments_empty_call_grpc(): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_assignment._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.search_assignments), "__call__" - ) as call: - call.return_value = reservation.SearchAssignmentsResponse() - client.search_assignments(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 = reservation.SearchAssignmentsRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_assignment._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_search_all_assignments_empty_call_grpc(): client = ReservationServiceClient( 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.search_all_assignments), "__call__" - ) as call: - call.return_value = reservation.SearchAllAssignmentsResponse() - client.search_all_assignments(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 = reservation.SearchAllAssignmentsRequest() + 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_assignment(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_move_assignment_empty_call_grpc(): - client = ReservationServiceClient( - 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.move_assignment), "__call__") as call: - call.return_value = reservation.Assignment() - client.move_assignment(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.MoveAssignmentRequest() +def test_delete_assignment_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) - assert args[0] == request_msg + unset_fields = transport.delete_assignment._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_assignment_empty_call_grpc(): +def test_delete_assignment_rest_flattened(): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_assignment), "__call__" - ) as call: - call.return_value = reservation.Assignment() - client.update_assignment(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 = reservation.UpdateAssignmentRequest() + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } - 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"} + client.delete_assignment(**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_bi_reservation_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/v1/{name=projects/*/locations/*/reservations/*/assignments/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_assignment_rest_flattened_error(transport: str = "rest"): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_bi_reservation), "__call__" - ) as call: - call.return_value = reservation.BiReservation() - client.get_bi_reservation(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.GetBiReservationRequest() + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_assignment( + reservation.DeleteAssignmentRequest(), + name="name_value", + ) - assert args[0] == request_msg +def test_search_assignments_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 = ReservationServiceClient( + 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_update_bi_reservation_empty_call_grpc(): - client = ReservationServiceClient( - 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.update_bi_reservation), "__call__" - ) as call: - call.return_value = reservation.BiReservation() - client.update_bi_reservation(request=None) + # Ensure method has been cached + assert ( + client._transport.search_assignments in client._transport._wrapped_methods + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.UpdateBiReservationRequest() + # 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.search_assignments + ] = mock_rpc - assert args[0] == request_msg + request = {} + client.search_assignments(request) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 -def test_transport_kind_grpc_asyncio(): - transport = ReservationServiceAsyncClient.get_transport_class("grpc_asyncio")( - credentials=async_anonymous_credentials() - ) - assert transport.kind == "grpc_asyncio" + client.search_assignments(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_initialize_client_w_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), transport="grpc_asyncio" - ) - assert client is not None +def test_search_assignments_rest_required_fields( + request_type=reservation.SearchAssignmentsRequest, +): + transport_class = transports.ReservationServiceRestTransport -# This test is a coverage 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_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + 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_reservation), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gcbr_reservation.Reservation( - name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, - multi_region_auxiliary=True, - edition=gcbr_reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, - ) - ) - await client.create_reservation(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 = gcbr_reservation.CreateReservationRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).search_assignments._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. -@pytest.mark.asyncio -async def test_list_reservations_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) - - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_reservations), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.ListReservationsResponse( - next_page_token="next_page_token_value", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).search_assignments._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", + "query", ) - await client.list_reservations(request=None) + ) + jsonified_request.update(unset_fields) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.ListReservationsRequest() + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" - assert args[0] == request_msg + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + # Designate an appropriate value for the returned response. + return_value = reservation.SearchAssignmentsResponse() + # 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 -# This test is a coverage 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_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + response_value = Response() + response_value.status_code = 200 - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_reservation), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.Reservation( - name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, - ) - ) - await client.get_reservation(request=None) + # Convert return value to protobuf type + return_value = reservation.SearchAssignmentsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.GetReservationRequest() + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - assert args[0] == request_msg + response = client.search_assignments(request) + + 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. -@pytest.mark.asyncio -async def test_delete_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_assignments_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_reservation), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_reservation(request=None) + unset_fields = transport.search_assignments._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + "query", + ) + ) + & set(("parent",)) + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.DeleteReservationRequest() - assert args[0] == request_msg +def test_search_assignments_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.SearchAssignmentsResponse() -# This test is a coverage 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_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_reservation), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - gcbr_reservation.Reservation( - name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, - multi_region_auxiliary=True, - edition=gcbr_reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, - ) + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + query="query_value", ) - await client.update_reservation(request=None) + mock_args.update(sample_request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = gcbr_reservation.UpdateReservationRequest() + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = reservation.SearchAssignmentsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - assert args[0] == request_msg + client.search_assignments(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}:searchAssignments" + % 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. -@pytest.mark.asyncio -async def test_failover_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_assignments_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.failover_reservation), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.Reservation( - name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, - ) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.search_assignments( + reservation.SearchAssignmentsRequest(), + parent="parent_value", + query="query_value", ) - await client.failover_reservation(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.FailoverReservationRequest() - - assert args[0] == request_msg -# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_assignments_rest_pager(transport: str = "rest"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_capacity_commitment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.CapacityCommitment( - name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, - ) + # 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 = ( + reservation.SearchAssignmentsResponse( + assignments=[ + reservation.Assignment(), + reservation.Assignment(), + reservation.Assignment(), + ], + next_page_token="abc", + ), + reservation.SearchAssignmentsResponse( + assignments=[], + next_page_token="def", + ), + reservation.SearchAssignmentsResponse( + assignments=[ + reservation.Assignment(), + ], + next_page_token="ghi", + ), + reservation.SearchAssignmentsResponse( + assignments=[ + reservation.Assignment(), + reservation.Assignment(), + ], + ), ) - await client.create_capacity_commitment(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.CreateCapacityCommitmentRequest() + # Two responses for two calls + response = response + response - assert args[0] == request_msg + # Wrap the values into proper Response objs + response = tuple( + reservation.SearchAssignmentsResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + sample_request = {"parent": "projects/sample1/locations/sample2"} -# This test is a coverage 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_capacity_commitments_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + pager = client.search_assignments(request=sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_capacity_commitments), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.ListCapacityCommitmentsResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_capacity_commitments(request=None) + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, reservation.Assignment) for i in results) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.ListCapacityCommitmentsRequest() + pages = list(client.search_assignments(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token - assert args[0] == request_msg +def test_search_all_assignments_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 = ReservationServiceClient( + 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. -@pytest.mark.asyncio -async def test_get_capacity_commitment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # 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.get_capacity_commitment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.CapacityCommitment( - name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, - ) + # Ensure method has been cached + assert ( + client._transport.search_all_assignments + in client._transport._wrapped_methods ) - await client.get_capacity_commitment(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.GetCapacityCommitmentRequest() - 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.search_all_assignments + ] = mock_rpc + request = {} + client.search_all_assignments(request) -# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # 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.delete_capacity_commitment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_capacity_commitment(request=None) + client.search_all_assignments(request) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.DeleteCapacityCommitmentRequest() + # 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_search_all_assignments_rest_required_fields( + request_type=reservation.SearchAllAssignmentsRequest, +): + transport_class = transports.ReservationServiceRestTransport -# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + 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_capacity_commitment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.CapacityCommitment( - name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, - ) - ) - await client.update_capacity_commitment(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 = reservation.UpdateCapacityCommitmentRequest() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).search_all_assignments._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. -@pytest.mark.asyncio -async def test_split_capacity_commitment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).search_all_assignments._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", + "query", + ) ) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.split_capacity_commitment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.SplitCapacityCommitmentResponse() - ) - await client.split_capacity_commitment(request=None) + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.SplitCapacityCommitmentRequest() - - assert args[0] == request_msg - - -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -@pytest.mark.asyncio -async def test_merge_capacity_commitments_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.merge_capacity_commitments), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.CapacityCommitment( - name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, - ) - ) - await client.merge_capacity_commitments(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.MergeCapacityCommitmentsRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = reservation.SearchAllAssignmentsResponse() + # 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. -@pytest.mark.asyncio -async def test_create_assignment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # Convert return value to protobuf type + return_value = reservation.SearchAllAssignmentsResponse.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.create_assignment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.Assignment( - name="name_value", - assignee="assignee_value", - job_type=reservation.Assignment.JobType.PIPELINE, - state=reservation.Assignment.State.PENDING, - enable_gemini_in_bigquery=True, - ) - ) - await client.create_assignment(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 = reservation.CreateAssignmentRequest() + response = client.search_all_assignments(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. -@pytest.mark.asyncio -async def test_list_assignments_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_all_assignments_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_assignments), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.ListAssignmentsResponse( - next_page_token="next_page_token_value", + unset_fields = transport.search_all_assignments._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + "query", ) ) - await client.list_assignments(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.ListAssignmentsRequest() - - assert args[0] == request_msg + & 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. -@pytest.mark.asyncio -async def test_delete_assignment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_all_assignments_rest_flattened(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_assignment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_assignment(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 = reservation.SearchAllAssignmentsResponse() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.DeleteAssignmentRequest() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} - assert args[0] == request_msg + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + query="query_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 = reservation.SearchAllAssignmentsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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. -@pytest.mark.asyncio -async def test_search_assignments_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + client.search_all_assignments(**mock_args) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.search_assignments), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.SearchAssignmentsResponse( - next_page_token="next_page_token_value", - ) + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}:searchAllAssignments" + % client.transport._host, + args[1], ) - await client.search_assignments(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.SearchAssignmentsRequest() - - assert args[0] == request_msg -# This test is a coverage 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_all_assignments_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_all_assignments_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.search_all_assignments), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.SearchAllAssignmentsResponse( - next_page_token="next_page_token_value", - ) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.search_all_assignments( + reservation.SearchAllAssignmentsRequest(), + parent="parent_value", + query="query_value", ) - await client.search_all_assignments(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.SearchAllAssignmentsRequest() - - assert args[0] == request_msg -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -@pytest.mark.asyncio -async def test_move_assignment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_search_all_assignments_rest_pager(transport: str = "rest"): + client = ReservationServiceClient( + 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 = ( + reservation.SearchAllAssignmentsResponse( + assignments=[ + reservation.Assignment(), + reservation.Assignment(), + reservation.Assignment(), + ], + next_page_token="abc", + ), + reservation.SearchAllAssignmentsResponse( + assignments=[], + next_page_token="def", + ), + reservation.SearchAllAssignmentsResponse( + assignments=[ + reservation.Assignment(), + ], + next_page_token="ghi", + ), + reservation.SearchAllAssignmentsResponse( + assignments=[ + reservation.Assignment(), + reservation.Assignment(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + reservation.SearchAllAssignmentsResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "projects/sample1/locations/sample2"} + + pager = client.search_all_assignments(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, reservation.Assignment) for i in results) + + pages = list(client.search_all_assignments(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_move_assignment_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 = ReservationServiceClient( + 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.move_assignment 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.move_assignment] = mock_rpc + + request = {} + client.move_assignment(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.move_assignment(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_move_assignment_rest_required_fields( + request_type=reservation.MoveAssignmentRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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() + ).move_assignment._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() + ).move_assignment._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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = reservation.Assignment() + # 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 = reservation.Assignment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.move_assignment(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_move_assignment_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.move_assignment._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_move_assignment_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.Assignment() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + destination_id="destination_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = reservation.Assignment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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.move_assignment(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/reservations/*/assignments/*}:move" + % client.transport._host, + args[1], + ) + + +def test_move_assignment_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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.move_assignment( + reservation.MoveAssignmentRequest(), + name="name_value", + destination_id="destination_id_value", + ) + + +def test_update_assignment_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.update_assignment 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_assignment + ] = mock_rpc + + request = {} + client.update_assignment(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.update_assignment(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_assignment_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.Assignment() + + # get arguments that satisfy an http rule for this method + sample_request = { + "assignment": { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } + } + + # get truthy value for each flattened field + mock_args = dict( + assignment=reservation.Assignment(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 = reservation.Assignment.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_assignment(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{assignment.name=projects/*/locations/*/reservations/*/assignments/*}" + % client.transport._host, + args[1], + ) + + +def test_update_assignment_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_assignment( + reservation.UpdateAssignmentRequest(), + assignment=reservation.Assignment(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_get_bi_reservation_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.get_bi_reservation 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_bi_reservation + ] = mock_rpc + + request = {} + client.get_bi_reservation(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_bi_reservation(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_bi_reservation_rest_required_fields( + request_type=reservation.GetBiReservationRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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_bi_reservation._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_bi_reservation._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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = reservation.BiReservation() + # 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 = reservation.BiReservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_bi_reservation(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_bi_reservation_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_bi_reservation._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_bi_reservation_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.BiReservation() + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "projects/sample1/locations/sample2/biReservation"} + + # 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 = reservation.BiReservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_bi_reservation(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/biReservation}" + % client.transport._host, + args[1], + ) + + +def test_get_bi_reservation_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_bi_reservation( + reservation.GetBiReservationRequest(), + name="name_value", + ) + + +def test_update_bi_reservation_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.update_bi_reservation + 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_bi_reservation + ] = mock_rpc + + request = {} + client.update_bi_reservation(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.update_bi_reservation(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_bi_reservation_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.BiReservation() + + # get arguments that satisfy an http rule for this method + sample_request = { + "bi_reservation": { + "name": "projects/sample1/locations/sample2/biReservation" + } + } + + # get truthy value for each flattened field + mock_args = dict( + bi_reservation=reservation.BiReservation(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 = reservation.BiReservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_bi_reservation(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{bi_reservation.name=projects/*/locations/*/biReservation}" + % client.transport._host, + args[1], + ) + + +def test_update_bi_reservation_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_bi_reservation( + reservation.UpdateBiReservationRequest(), + bi_reservation=reservation.BiReservation(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_get_iam_policy_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.get_iam_policy 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_iam_policy] = mock_rpc + + request = {} + client.get_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_iam_policy(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_iam_policy_rest_required_fields( + request_type=iam_policy_pb2.GetIamPolicyRequest, +): + transport_class = transports.ReservationServiceRestTransport + + request_init = {} + request_init["resource"] = "" + request = request_type(**request_init) + pb_request = 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_iam_policy._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["resource"] = "resource_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_iam_policy._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("options",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "resource" in jsonified_request + assert jsonified_request["resource"] == "resource_value" + + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = policy_pb2.Policy() + # 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 + 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 + + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.get_iam_policy(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_iam_policy_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_iam_policy._get_unset_required_fields({}) + assert set(unset_fields) == (set(("options",)) & set(("resource",))) + + +def test_get_iam_policy_rest_flattened(): + client = ReservationServiceClient( + 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 = policy_pb2.Policy() + + # get arguments that satisfy an http rule for this method + sample_request = { + "resource": "projects/sample1/locations/sample2/reservations/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + resource="resource_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.get_iam_policy(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{resource=projects/*/locations/*/reservations/*}:getIamPolicy" + % client.transport._host, + args[1], + ) + + +def test_get_iam_policy_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_iam_policy( + iam_policy_pb2.GetIamPolicyRequest(), + resource="resource_value", + ) + + +def test_set_iam_policy_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 = ReservationServiceClient( + 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.set_iam_policy in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.set_iam_policy] = mock_rpc + + request = {} + client.set_iam_policy(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.set_iam_policy(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_iam_policy_rest_required_fields( + request_type=iam_policy_pb2.SetIamPolicyRequest, +): + transport_class = transports.ReservationServiceRestTransport + + request_init = {} + request_init["resource"] = "" + request = request_type(**request_init) + pb_request = 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() + ).set_iam_policy._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["resource"] = "resource_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).set_iam_policy._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "resource" in jsonified_request + assert jsonified_request["resource"] == "resource_value" + + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = policy_pb2.Policy() + # 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 + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.set_iam_policy(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_set_iam_policy_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.set_iam_policy._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "resource", + "policy", + ) + ) + ) + + +def test_set_iam_policy_rest_flattened(): + client = ReservationServiceClient( + 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 = policy_pb2.Policy() + + # get arguments that satisfy an http rule for this method + sample_request = { + "resource": "projects/sample1/locations/sample2/reservations/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + resource="resource_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + client.set_iam_policy(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{resource=projects/*/locations/*/reservations/*}:setIamPolicy" + % client.transport._host, + args[1], + ) + + +def test_set_iam_policy_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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.set_iam_policy( + iam_policy_pb2.SetIamPolicyRequest(), + resource="resource_value", + ) + + +def test_test_iam_permissions_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 = ReservationServiceClient( + 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.test_iam_permissions 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.test_iam_permissions + ] = mock_rpc + + request = {} + client.test_iam_permissions(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.test_iam_permissions(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_test_iam_permissions_rest_required_fields( + request_type=iam_policy_pb2.TestIamPermissionsRequest, +): + transport_class = transports.ReservationServiceRestTransport + + request_init = {} + request_init["resource"] = "" + request_init["permissions"] = "" + request = request_type(**request_init) + pb_request = 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() + ).test_iam_permissions._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["resource"] = "resource_value" + jsonified_request["permissions"] = "permissions_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).test_iam_permissions._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "resource" in jsonified_request + assert jsonified_request["resource"] == "resource_value" + assert "permissions" in jsonified_request + assert jsonified_request["permissions"] == "permissions_value" + + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = iam_policy_pb2.TestIamPermissionsResponse() + # 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 + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.test_iam_permissions(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_test_iam_permissions_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.test_iam_permissions._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "resource", + "permissions", + ) + ) + ) + + +def test_create_reservation_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: + client = ReservationServiceClient( + 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_reservation_group + 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_reservation_group + ] = mock_rpc + + request = {} + client.create_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.create_reservation_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_reservation_group_rest_required_fields( + request_type=reservation.CreateReservationGroupRequest, +): + transport_class = transports.ReservationServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request_init["reservation_group_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + assert "reservationGroupId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_reservation_group._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "reservationGroupId" in jsonified_request + assert ( + jsonified_request["reservationGroupId"] == request_init["reservation_group_id"] + ) + + jsonified_request["parent"] = "parent_value" + jsonified_request["reservationGroupId"] = "reservation_group_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_reservation_group._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("reservation_group_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 "reservationGroupId" in jsonified_request + assert jsonified_request["reservationGroupId"] == "reservation_group_id_value" + + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = reservation.ReservationGroup() + # 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 = reservation.ReservationGroup.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_reservation_group(request) + + expected_params = [ + ( + "reservationGroupId", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_reservation_group_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_reservation_group._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("reservationGroupId",)) + & set( + ( + "parent", + "reservationGroupId", + "reservationGroup", + ) + ) + ) + + +def test_get_reservation_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: + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.get_reservation_group + 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_reservation_group + ] = mock_rpc + + request = {} + client.get_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_reservation_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_reservation_group_rest_required_fields( + request_type=reservation.GetReservationGroupRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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_reservation_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_reservation_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = reservation.ReservationGroup() + # 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 = reservation.ReservationGroup.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_reservation_group(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_reservation_group_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_reservation_group._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_reservation_group_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.ReservationGroup() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/reservationGroups/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = reservation.ReservationGroup.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_reservation_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/v1/{name=projects/*/locations/*/reservationGroups/*}" + % client.transport._host, + args[1], + ) + + +def test_get_reservation_group_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_reservation_group( + reservation.GetReservationGroupRequest(), + name="name_value", + ) + + +def test_delete_reservation_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: + client = ReservationServiceClient( + 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_reservation_group + 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_reservation_group + ] = mock_rpc + + request = {} + client.delete_reservation_group(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_reservation_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_delete_reservation_group_rest_required_fields( + request_type=reservation.DeleteReservationGroupRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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_reservation_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() + ).delete_reservation_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 = ReservationServiceClient( + 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_reservation_group(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_reservation_group_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_reservation_group._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_reservation_group_rest_flattened(): + client = ReservationServiceClient( + 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": "projects/sample1/locations/sample2/reservationGroups/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = "" + response_value._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_reservation_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/v1/{name=projects/*/locations/*/reservationGroups/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_reservation_group_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_reservation_group( + reservation.DeleteReservationGroupRequest(), + name="name_value", + ) + + +def test_list_reservation_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: + client = ReservationServiceClient( + 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_reservation_groups + 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_reservation_groups + ] = mock_rpc + + request = {} + client.list_reservation_groups(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_reservation_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_list_reservation_groups_rest_required_fields( + request_type=reservation.ListReservationGroupsRequest, +): + transport_class = transports.ReservationServiceRestTransport + + 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_reservation_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() + ).list_reservation_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 = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = reservation.ListReservationGroupsResponse() + # 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 = reservation.ListReservationGroupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_reservation_groups(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_reservation_groups_rest_unset_required_fields(): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_reservation_groups._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +def test_list_reservation_groups_rest_flattened(): + client = ReservationServiceClient( + 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 = reservation.ListReservationGroupsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = reservation.ListReservationGroupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_reservation_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/v1/{parent=projects/*/locations/*}/reservationGroups" + % client.transport._host, + args[1], + ) + + +def test_list_reservation_groups_rest_flattened_error(transport: str = "rest"): + client = ReservationServiceClient( + 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_reservation_groups( + reservation.ListReservationGroupsRequest(), + parent="parent_value", + ) + + +def test_list_reservation_groups_rest_pager(transport: str = "rest"): + client = ReservationServiceClient( + 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 = ( + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + next_page_token="abc", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[], + next_page_token="def", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + ], + next_page_token="ghi", + ), + reservation.ListReservationGroupsResponse( + reservation_groups=[ + reservation.ReservationGroup(), + reservation.ReservationGroup(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + reservation.ListReservationGroupsResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "projects/sample1/locations/sample2"} + + pager = client.list_reservation_groups(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, reservation.ReservationGroup) for i in results) + + pages = list(client.list_reservation_groups(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.ReservationServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.ReservationServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = ReservationServiceClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide an api_key and a transport instance. + transport = transports.ReservationServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = ReservationServiceClient( + 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 = ReservationServiceClient( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.ReservationServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = ReservationServiceClient( + client_options={"scopes": ["1", "2"]}, + transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.ReservationServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = ReservationServiceClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.ReservationServiceGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.ReservationServiceGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.ReservationServiceGrpcTransport, + transports.ReservationServiceGrpcAsyncIOTransport, + transports.ReservationServiceRestTransport, + ], +) +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 = ReservationServiceClient.get_transport_class("grpc")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "grpc" + + +def test_initialize_client_w_grpc(): + client = ReservationServiceClient( + 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_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation), "__call__" + ) as call: + call.return_value = gcbr_reservation.Reservation() + client.create_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = gcbr_reservation.CreateReservationRequest() + + assert args[0] == request_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_reservations_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reservations), "__call__" + ) as call: + call.return_value = reservation.ListReservationsResponse() + client.list_reservations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListReservationsRequest() + + assert args[0] == request_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_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_reservation), "__call__") as call: + call.return_value = reservation.Reservation() + client.get_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetReservationRequest() + + assert args[0] == request_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_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation), "__call__" + ) as call: + call.return_value = None + client.delete_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteReservationRequest() + + assert args[0] == request_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_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_reservation), "__call__" + ) as call: + call.return_value = gcbr_reservation.Reservation() + client.update_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = gcbr_reservation.UpdateReservationRequest() + + assert args[0] == request_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_failover_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.failover_reservation), "__call__" + ) as call: + call.return_value = reservation.Reservation() + client.failover_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.FailoverReservationRequest() + + assert args[0] == request_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_capacity_commitment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_capacity_commitment), "__call__" + ) as call: + call.return_value = reservation.CapacityCommitment() + client.create_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateCapacityCommitmentRequest() + + assert args[0] == request_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_capacity_commitments_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_capacity_commitments), "__call__" + ) as call: + call.return_value = reservation.ListCapacityCommitmentsResponse() + client.list_capacity_commitments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListCapacityCommitmentsRequest() + + assert args[0] == request_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_capacity_commitment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_capacity_commitment), "__call__" + ) as call: + call.return_value = reservation.CapacityCommitment() + client.get_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetCapacityCommitmentRequest() + + assert args[0] == request_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_capacity_commitment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_capacity_commitment), "__call__" + ) as call: + call.return_value = None + client.delete_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteCapacityCommitmentRequest() + + assert args[0] == request_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_capacity_commitment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_capacity_commitment), "__call__" + ) as call: + call.return_value = reservation.CapacityCommitment() + client.update_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.UpdateCapacityCommitmentRequest() + + assert args[0] == request_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_split_capacity_commitment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.split_capacity_commitment), "__call__" + ) as call: + call.return_value = reservation.SplitCapacityCommitmentResponse() + client.split_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.SplitCapacityCommitmentRequest() + + assert args[0] == request_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_merge_capacity_commitments_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.merge_capacity_commitments), "__call__" + ) as call: + call.return_value = reservation.CapacityCommitment() + client.merge_capacity_commitments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.MergeCapacityCommitmentsRequest() + + assert args[0] == request_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_assignment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_assignment), "__call__" + ) as call: + call.return_value = reservation.Assignment() + client.create_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateAssignmentRequest() + + assert args[0] == request_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_assignments_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_assignments), "__call__") as call: + call.return_value = reservation.ListAssignmentsResponse() + client.list_assignments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListAssignmentsRequest() + + assert args[0] == request_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_assignment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_assignment), "__call__" + ) as call: + call.return_value = None + client.delete_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteAssignmentRequest() + + assert args[0] == request_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_search_assignments_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.search_assignments), "__call__" + ) as call: + call.return_value = reservation.SearchAssignmentsResponse() + client.search_assignments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.SearchAssignmentsRequest() + + assert args[0] == request_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_search_all_assignments_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.search_all_assignments), "__call__" + ) as call: + call.return_value = reservation.SearchAllAssignmentsResponse() + client.search_all_assignments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.SearchAllAssignmentsRequest() + + assert args[0] == request_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_move_assignment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.move_assignment), "__call__") as call: + call.return_value = reservation.Assignment() + client.move_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.MoveAssignmentRequest() + + assert args[0] == request_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_assignment_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_assignment), "__call__" + ) as call: + call.return_value = reservation.Assignment() + client.update_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.UpdateAssignmentRequest() + + assert args[0] == request_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_bi_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_bi_reservation), "__call__" + ) as call: + call.return_value = reservation.BiReservation() + client.get_bi_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetBiReservationRequest() + + assert args[0] == request_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_bi_reservation_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_bi_reservation), "__call__" + ) as call: + call.return_value = reservation.BiReservation() + client.update_bi_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.UpdateBiReservationRequest() + + assert args[0] == request_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_iam_policy_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + call.return_value = policy_pb2.Policy() + client.get_iam_policy(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.GetIamPolicyRequest() + + assert args[0] == request_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_set_iam_policy_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + call.return_value = policy_pb2.Policy() + client.set_iam_policy(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.SetIamPolicyRequest() + + assert args[0] == request_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_test_iam_permissions_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + call.return_value = iam_policy_pb2.TestIamPermissionsResponse() + client.test_iam_permissions(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.TestIamPermissionsRequest() + + assert args[0] == request_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_reservation_group_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation_group), "__call__" + ) as call: + call.return_value = reservation.ReservationGroup() + client.create_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateReservationGroupRequest() + + assert args[0] == request_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_reservation_group_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + call.return_value = reservation.ReservationGroup() + client.get_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetReservationGroupRequest() + + assert args[0] == request_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_reservation_group_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + call.return_value = None + client.delete_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteReservationGroupRequest() + + assert args[0] == request_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_reservation_groups_empty_call_grpc(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + call.return_value = reservation.ListReservationGroupsResponse() + client.list_reservation_groups(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListReservationGroupsRequest() + + assert args[0] == request_msg + + +def test_transport_kind_grpc_asyncio(): + transport = ReservationServiceAsyncClient.get_transport_class("grpc_asyncio")( + credentials=async_anonymous_credentials() + ) + assert transport.kind == "grpc_asyncio" + + +def test_initialize_client_w_grpc_asyncio(): + client = ReservationServiceAsyncClient( + 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_create_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gcbr_reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=gcbr_reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", + ) + ) + await client.create_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = gcbr_reservation.CreateReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservations_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reservations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListReservationsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_reservations(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListReservationsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_reservation), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", + ) + ) + await client.get_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_reservation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gcbr_reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=gcbr_reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", + ) + ) + await client.update_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = gcbr_reservation.UpdateReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_failover_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.failover_reservation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", + ) + ) + await client.failover_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.FailoverReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_capacity_commitment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.CapacityCommitment( + name="name_value", + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + is_flat_rate=True, + ) + ) + await client.create_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateCapacityCommitmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_capacity_commitments_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_capacity_commitments), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListCapacityCommitmentsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_capacity_commitments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListCapacityCommitmentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_capacity_commitment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.CapacityCommitment( + name="name_value", + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + is_flat_rate=True, + ) + ) + await client.get_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetCapacityCommitmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_capacity_commitment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteCapacityCommitmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_capacity_commitment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_capacity_commitment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.CapacityCommitment( + name="name_value", + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + is_flat_rate=True, + ) + ) + await client.update_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.UpdateCapacityCommitmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_split_capacity_commitment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.split_capacity_commitment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.SplitCapacityCommitmentResponse() + ) + await client.split_capacity_commitment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.SplitCapacityCommitmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_merge_capacity_commitments_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.merge_capacity_commitments), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.CapacityCommitment( + name="name_value", + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + is_flat_rate=True, + ) + ) + await client.merge_capacity_commitments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.MergeCapacityCommitmentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_assignment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_assignment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.Assignment( + name="name_value", + assignee="assignee_value", + job_type=reservation.Assignment.JobType.PIPELINE, + state=reservation.Assignment.State.PENDING, + enable_gemini_in_bigquery=True, + ) + ) + await client.create_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateAssignmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_assignments_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_assignments), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListAssignmentsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_assignments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListAssignmentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_assignment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_assignment), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteAssignmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_assignments_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.search_assignments), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.SearchAssignmentsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.search_assignments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.SearchAssignmentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_all_assignments_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.search_all_assignments), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.SearchAllAssignmentsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.search_all_assignments(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.SearchAllAssignmentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_move_assignment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.move_assignment), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.Assignment( + name="name_value", + assignee="assignee_value", + job_type=reservation.Assignment.JobType.PIPELINE, + state=reservation.Assignment.State.PENDING, + enable_gemini_in_bigquery=True, + ) + ) + await client.move_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.MoveAssignmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_assignment_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", ) # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.move_assignment), "__call__") as call: + with mock.patch.object( + type(client.transport.update_assignment), "__call__" + ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( reservation.Assignment( @@ -15173,118 +19100,1342 @@ async def test_move_assignment_empty_call_grpc_asyncio(): enable_gemini_in_bigquery=True, ) ) - await client.move_assignment(request=None) + await client.update_assignment(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.UpdateAssignmentRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_bi_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_bi_reservation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.BiReservation( + name="name_value", + size=443, + ) + ) + await client.get_bi_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetBiReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_bi_reservation_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_bi_reservation), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.BiReservation( + name="name_value", + size=443, + ) + ) + await client.update_bi_reservation(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.UpdateBiReservationRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_iam_policy_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + ) + await client.get_iam_policy(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.GetIamPolicyRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_iam_policy_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + policy_pb2.Policy( + version=774, + etag=b"etag_blob", + ) + ) + await client.set_iam_policy(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.SetIamPolicyRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_test_iam_permissions_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + iam_policy_pb2.TestIamPermissionsResponse( + permissions=["permissions_value"], + ) + ) + await client.test_iam_permissions(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.TestIamPermissionsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_group_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup( + name="name_value", + ) + ) + await client.create_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateReservationGroupRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_group_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ReservationGroup( + name="name_value", + ) + ) + await client.get_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetReservationGroupRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_group_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteReservationGroupRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_reservation_groups_empty_call_grpc_asyncio(): + client = ReservationServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + reservation.ListReservationGroupsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_reservation_groups(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListReservationGroupsRequest() + + assert args[0] == request_msg + + +def test_transport_kind_rest(): + transport = ReservationServiceClient.get_transport_class("rest")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "rest" + + +def test_create_reservation_rest_bad_request( + request_type=gcbr_reservation.CreateReservationRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.create_reservation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + gcbr_reservation.CreateReservationRequest, + dict, + ], +) +def test_create_reservation_rest_call_success(request_type): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["reservation"] = { + "name": "name_value", + "slot_capacity": 1391, + "ignore_idle_slots": True, + "autoscale": {"current_slots": 1431, "max_slots": 986}, + "concurrency": 1195, + "creation_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "multi_region_auxiliary": True, + "edition": 1, + "primary_location": "primary_location_value", + "secondary_location": "secondary_location_value", + "original_primary_location": "original_primary_location_value", + "max_slots": 986, + "scaling_mode": 1, + "labels": {}, + "reservation_group": "reservation_group_value", + "replication_status": { + "error": { + "code": 411, + "message": "message_value", + "details": [ + { + "type_url": "type.googleapis.com/google.protobuf.Duration", + "value": b"\x08\x0c\x10\xdb\x07", + } + ], + }, + "last_error_time": {}, + "last_replication_time": {}, + "soft_failover_start_time": {}, + }, + "scheduling_policy": {"concurrency": 1195, "max_slots": 986}, + } + # 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 = gcbr_reservation.CreateReservationRequest.meta.fields["reservation"] + + 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["reservation"].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["reservation"][field])): + del request_init["reservation"][field][i][subfield] + else: + del request_init["reservation"][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 = gcbr_reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=gcbr_reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_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 = gcbr_reservation.Reservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_reservation(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, gcbr_reservation.Reservation) + assert response.name == "name_value" + assert response.slot_capacity == 1391 + assert response.ignore_idle_slots is True + assert response.concurrency == 1195 + assert response.multi_region_auxiliary is True + assert response.edition == gcbr_reservation.Edition.STANDARD + assert response.primary_location == "primary_location_value" + assert response.secondary_location == "secondary_location_value" + assert response.original_primary_location == "original_primary_location_value" + assert response.max_slots == 986 + assert ( + response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + ) + assert response.reservation_group == "reservation_group_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_reservation_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), + ) + client = ReservationServiceClient(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.ReservationServiceRestInterceptor, "post_create_reservation" + ) as post, mock.patch.object( + transports.ReservationServiceRestInterceptor, + "post_create_reservation_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.ReservationServiceRestInterceptor, "pre_create_reservation" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = gcbr_reservation.CreateReservationRequest.pb( + gcbr_reservation.CreateReservationRequest() + ) + 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 = gcbr_reservation.Reservation.to_json( + gcbr_reservation.Reservation() + ) + req.return_value.content = return_value + + request = gcbr_reservation.CreateReservationRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gcbr_reservation.Reservation() + post_with_metadata.return_value = gcbr_reservation.Reservation(), metadata + + client.create_reservation( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_reservations_rest_bad_request( + request_type=reservation.ListReservationsRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_reservations(request) + + +@pytest.mark.parametrize( + "request_type", + [ + reservation.ListReservationsRequest, + dict, + ], +) +def test_list_reservations_rest_call_success(request_type): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = reservation.ListReservationsResponse( + 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 = reservation.ListReservationsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_reservations(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListReservationsPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_reservations_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), + ) + client = ReservationServiceClient(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.ReservationServiceRestInterceptor, "post_list_reservations" + ) as post, mock.patch.object( + transports.ReservationServiceRestInterceptor, + "post_list_reservations_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.ReservationServiceRestInterceptor, "pre_list_reservations" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = reservation.ListReservationsRequest.pb( + reservation.ListReservationsRequest() + ) + 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 = reservation.ListReservationsResponse.to_json( + reservation.ListReservationsResponse() + ) + req.return_value.content = return_value + + request = reservation.ListReservationsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = reservation.ListReservationsResponse() + post_with_metadata.return_value = ( + reservation.ListReservationsResponse(), + metadata, + ) + + client.list_reservations( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_reservation_rest_bad_request( + request_type=reservation.GetReservationRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_reservation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + reservation.GetReservationRequest, + dict, + ], +) +def test_get_reservation_rest_call_success(request_type): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/reservations/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 = reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_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 = reservation.Reservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_reservation(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, reservation.Reservation) + assert response.name == "name_value" + assert response.slot_capacity == 1391 + assert response.ignore_idle_slots is True + assert response.concurrency == 1195 + assert response.multi_region_auxiliary is True + assert response.edition == reservation.Edition.STANDARD + assert response.primary_location == "primary_location_value" + assert response.secondary_location == "secondary_location_value" + assert response.original_primary_location == "original_primary_location_value" + assert response.max_slots == 986 + assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.reservation_group == "reservation_group_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_reservation_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), + ) + client = ReservationServiceClient(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.ReservationServiceRestInterceptor, "post_get_reservation" + ) as post, mock.patch.object( + transports.ReservationServiceRestInterceptor, + "post_get_reservation_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.ReservationServiceRestInterceptor, "pre_get_reservation" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = reservation.GetReservationRequest.pb( + reservation.GetReservationRequest() + ) + 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 = reservation.Reservation.to_json(reservation.Reservation()) + req.return_value.content = return_value + + request = reservation.GetReservationRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = reservation.Reservation() + post_with_metadata.return_value = reservation.Reservation(), metadata + + client.get_reservation( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_delete_reservation_rest_bad_request( + request_type=reservation.DeleteReservationRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/reservations/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_reservation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + reservation.DeleteReservationRequest, + dict, + ], +) +def test_delete_reservation_rest_call_success(request_type): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/reservations/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_reservation(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_reservation_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), + ) + client = ReservationServiceClient(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.ReservationServiceRestInterceptor, "pre_delete_reservation" + ) as pre: + pre.assert_not_called() + pb_message = reservation.DeleteReservationRequest.pb( + reservation.DeleteReservationRequest() + ) + 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 = reservation.DeleteReservationRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + + client.delete_reservation( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + + +def test_update_reservation_rest_bad_request( + request_type=gcbr_reservation.UpdateReservationRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "reservation": { + "name": "projects/sample1/locations/sample2/reservations/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_reservation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + gcbr_reservation.UpdateReservationRequest, + dict, + ], +) +def test_update_reservation_rest_call_success(request_type): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "reservation": { + "name": "projects/sample1/locations/sample2/reservations/sample3" + } + } + request_init["reservation"] = { + "name": "projects/sample1/locations/sample2/reservations/sample3", + "slot_capacity": 1391, + "ignore_idle_slots": True, + "autoscale": {"current_slots": 1431, "max_slots": 986}, + "concurrency": 1195, + "creation_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "multi_region_auxiliary": True, + "edition": 1, + "primary_location": "primary_location_value", + "secondary_location": "secondary_location_value", + "original_primary_location": "original_primary_location_value", + "max_slots": 986, + "scaling_mode": 1, + "labels": {}, + "reservation_group": "reservation_group_value", + "replication_status": { + "error": { + "code": 411, + "message": "message_value", + "details": [ + { + "type_url": "type.googleapis.com/google.protobuf.Duration", + "value": b"\x08\x0c\x10\xdb\x07", + } + ], + }, + "last_error_time": {}, + "last_replication_time": {}, + "soft_failover_start_time": {}, + }, + "scheduling_policy": {"concurrency": 1195, "max_slots": 986}, + } + # 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 = gcbr_reservation.UpdateReservationRequest.meta.fields["reservation"] + + 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["reservation"].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["reservation"][field])): + del request_init["reservation"][field][i][subfield] + else: + del request_init["reservation"][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 = gcbr_reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=gcbr_reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.MoveAssignmentRequest() + # 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 = gcbr_reservation.Reservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_reservation(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, gcbr_reservation.Reservation) + assert response.name == "name_value" + assert response.slot_capacity == 1391 + assert response.ignore_idle_slots is True + assert response.concurrency == 1195 + assert response.multi_region_auxiliary is True + assert response.edition == gcbr_reservation.Edition.STANDARD + assert response.primary_location == "primary_location_value" + assert response.secondary_location == "secondary_location_value" + assert response.original_primary_location == "original_primary_location_value" + assert response.max_slots == 986 + assert ( + response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + ) + assert response.reservation_group == "reservation_group_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_update_assignment_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_reservation_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), ) + client = ReservationServiceClient(transport=transport) - # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_assignment), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.Assignment( - name="name_value", - assignee="assignee_value", - job_type=reservation.Assignment.JobType.PIPELINE, - state=reservation.Assignment.State.PENDING, - enable_gemini_in_bigquery=True, - ) + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ReservationServiceRestInterceptor, "post_update_reservation" + ) as post, mock.patch.object( + transports.ReservationServiceRestInterceptor, + "post_update_reservation_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.ReservationServiceRestInterceptor, "pre_update_reservation" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = gcbr_reservation.UpdateReservationRequest.pb( + gcbr_reservation.UpdateReservationRequest() ) - await client.update_assignment(request=None) + 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 = reservation.UpdateAssignmentRequest() + 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 = gcbr_reservation.Reservation.to_json( + gcbr_reservation.Reservation() + ) + req.return_value.content = return_value - assert args[0] == request_msg + request = gcbr_reservation.UpdateReservationRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gcbr_reservation.Reservation() + post_with_metadata.return_value = gcbr_reservation.Reservation(), metadata + + client.update_reservation( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -# This test is a coverage 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_bi_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + +def test_failover_reservation_rest_bad_request( + request_type=reservation.FailoverReservationRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_bi_reservation), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.BiReservation( - name="name_value", - size=443, - ) + # 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.failover_reservation(request) + + +@pytest.mark.parametrize( + "request_type", + [ + reservation.FailoverReservationRequest, + dict, + ], +) +def test_failover_reservation_rest_call_success(request_type): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/reservations/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 = reservation.Reservation( + name="name_value", + slot_capacity=1391, + ignore_idle_slots=True, + concurrency=1195, + multi_region_auxiliary=True, + edition=reservation.Edition.STANDARD, + primary_location="primary_location_value", + secondary_location="secondary_location_value", + original_primary_location="original_primary_location_value", + max_slots=986, + scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + reservation_group="reservation_group_value", ) - await client.get_bi_reservation(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = reservation.GetBiReservationRequest() + # 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 = reservation.Reservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.failover_reservation(request) + # Establish that the response is the type that we expect. + assert isinstance(response, reservation.Reservation) + assert response.name == "name_value" + assert response.slot_capacity == 1391 + assert response.ignore_idle_slots is True + assert response.concurrency == 1195 + assert response.multi_region_auxiliary is True + assert response.edition == reservation.Edition.STANDARD + assert response.primary_location == "primary_location_value" + assert response.secondary_location == "secondary_location_value" + assert response.original_primary_location == "original_primary_location_value" + assert response.max_slots == 986 + assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.reservation_group == "reservation_group_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_update_bi_reservation_empty_call_grpc_asyncio(): - client = ReservationServiceAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_failover_reservation_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), ) + client = ReservationServiceClient(transport=transport) - # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.update_bi_reservation), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - reservation.BiReservation( - name="name_value", - size=443, - ) + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.ReservationServiceRestInterceptor, "post_failover_reservation" + ) as post, mock.patch.object( + transports.ReservationServiceRestInterceptor, + "post_failover_reservation_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.ReservationServiceRestInterceptor, "pre_failover_reservation" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = reservation.FailoverReservationRequest.pb( + reservation.FailoverReservationRequest() ) - await client.update_bi_reservation(request=None) + 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 = reservation.UpdateBiReservationRequest() + 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 = reservation.Reservation.to_json(reservation.Reservation()) + req.return_value.content = return_value - assert args[0] == request_msg + request = reservation.FailoverReservationRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = reservation.Reservation() + post_with_metadata.return_value = reservation.Reservation(), metadata + client.failover_reservation( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) -def test_transport_kind_rest(): - transport = ReservationServiceClient.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_create_reservation_rest_bad_request( - request_type=gcbr_reservation.CreateReservationRequest, +def test_create_capacity_commitment_rest_bad_request( + request_type=reservation.CreateCapacityCommitmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -15305,60 +20456,53 @@ def test_create_reservation_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_reservation(request) + client.create_capacity_commitment(request) @pytest.mark.parametrize( "request_type", [ - gcbr_reservation.CreateReservationRequest, + reservation.CreateCapacityCommitmentRequest, dict, ], ) -def test_create_reservation_rest_call_success(request_type): +def test_create_capacity_commitment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "projects/sample1/locations/sample2"} - request_init["reservation"] = { + request_init["capacity_commitment"] = { "name": "name_value", - "slot_capacity": 1391, - "ignore_idle_slots": True, - "autoscale": {"current_slots": 1431, "max_slots": 986}, - "concurrency": 1195, - "creation_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, + "slot_count": 1098, + "plan": 3, + "state": 1, + "commitment_start_time": {"seconds": 751, "nanos": 543}, + "commitment_end_time": {}, + "failure_status": { + "code": 411, + "message": "message_value", + "details": [ + { + "type_url": "type.googleapis.com/google.protobuf.Duration", + "value": b"\x08\x0c\x10\xdb\x07", + } + ], + }, + "renewal_plan": 3, "multi_region_auxiliary": True, "edition": 1, - "primary_location": "primary_location_value", - "secondary_location": "secondary_location_value", - "original_primary_location": "original_primary_location_value", - "max_slots": 986, - "scaling_mode": 1, - "replication_status": { - "error": { - "code": 411, - "message": "message_value", - "details": [ - { - "type_url": "type.googleapis.com/google.protobuf.Duration", - "value": b"\x08\x0c\x10\xdb\x07", - } - ], - }, - "last_error_time": {}, - "last_replication_time": {}, - "soft_failover_start_time": {}, - }, + "is_flat_rate": 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 = gcbr_reservation.CreateReservationRequest.meta.fields["reservation"] + test_field = reservation.CreateCapacityCommitmentRequest.meta.fields[ + "capacity_commitment" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -15386,7 +20530,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["reservation"].items(): # pragma: NO COVER + for field, value in request_init["capacity_commitment"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -15416,27 +20560,24 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["reservation"][field])): - del request_init["reservation"][field][i][subfield] + for i in range(0, len(request_init["capacity_commitment"][field])): + del request_init["capacity_commitment"][field][i][subfield] else: - del request_init["reservation"][field][subfield] + del request_init["capacity_commitment"][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 = gcbr_reservation.Reservation( + return_value = reservation.CapacityCommitment( name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, multi_region_auxiliary=True, - edition=gcbr_reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + edition=reservation.Edition.STANDARD, + is_flat_rate=True, ) # Wrap the value into a proper Response obj @@ -15444,32 +20585,27 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gcbr_reservation.Reservation.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_reservation(request) + response = client.create_capacity_commitment(request) # Establish that the response is the type that we expect. - assert isinstance(response, gcbr_reservation.Reservation) + assert isinstance(response, reservation.CapacityCommitment) assert response.name == "name_value" - assert response.slot_capacity == 1391 - assert response.ignore_idle_slots is True - assert response.concurrency == 1195 + assert response.slot_count == 1098 + assert response.plan == reservation.CapacityCommitment.CommitmentPlan.FLEX + assert response.state == reservation.CapacityCommitment.State.PENDING + assert response.renewal_plan == reservation.CapacityCommitment.CommitmentPlan.FLEX assert response.multi_region_auxiliary is True - assert response.edition == gcbr_reservation.Edition.STANDARD - assert response.primary_location == "primary_location_value" - assert response.secondary_location == "secondary_location_value" - assert response.original_primary_location == "original_primary_location_value" - assert response.max_slots == 986 - assert ( - response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY - ) + assert response.edition == reservation.Edition.STANDARD + assert response.is_flat_rate is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_reservation_rest_interceptors(null_interceptor): +def test_create_capacity_commitment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15483,18 +20619,18 @@ def test_create_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_create_reservation" + transports.ReservationServiceRestInterceptor, "post_create_capacity_commitment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_create_reservation_with_metadata", + "post_create_capacity_commitment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_create_reservation" + transports.ReservationServiceRestInterceptor, "pre_create_capacity_commitment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = gcbr_reservation.CreateReservationRequest.pb( - gcbr_reservation.CreateReservationRequest() + pb_message = reservation.CreateCapacityCommitmentRequest.pb( + reservation.CreateCapacityCommitmentRequest() ) transcode.return_value = { "method": "post", @@ -15506,21 +20642,21 @@ def test_create_reservation_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 = gcbr_reservation.Reservation.to_json( - gcbr_reservation.Reservation() + return_value = reservation.CapacityCommitment.to_json( + reservation.CapacityCommitment() ) req.return_value.content = return_value - request = gcbr_reservation.CreateReservationRequest() + request = reservation.CreateCapacityCommitmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gcbr_reservation.Reservation() - post_with_metadata.return_value = gcbr_reservation.Reservation(), metadata + post.return_value = reservation.CapacityCommitment() + post_with_metadata.return_value = reservation.CapacityCommitment(), metadata - client.create_reservation( + client.create_capacity_commitment( request, metadata=[ ("key", "val"), @@ -15533,8 +20669,8 @@ def test_create_reservation_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_reservations_rest_bad_request( - request_type=reservation.ListReservationsRequest, +def test_list_capacity_commitments_rest_bad_request( + request_type=reservation.ListCapacityCommitmentsRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -15555,17 +20691,17 @@ def test_list_reservations_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_reservations(request) + client.list_capacity_commitments(request) @pytest.mark.parametrize( "request_type", [ - reservation.ListReservationsRequest, + reservation.ListCapacityCommitmentsRequest, dict, ], ) -def test_list_reservations_rest_call_success(request_type): +def test_list_capacity_commitments_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -15577,7 +20713,7 @@ def test_list_reservations_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 = reservation.ListReservationsResponse( + return_value = reservation.ListCapacityCommitmentsResponse( next_page_token="next_page_token_value", ) @@ -15586,20 +20722,20 @@ def test_list_reservations_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.ListReservationsResponse.pb(return_value) + return_value = reservation.ListCapacityCommitmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_reservations(request) + response = client.list_capacity_commitments(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListReservationsPager) + assert isinstance(response, pagers.ListCapacityCommitmentsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_reservations_rest_interceptors(null_interceptor): +def test_list_capacity_commitments_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15613,18 +20749,18 @@ def test_list_reservations_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_list_reservations" + transports.ReservationServiceRestInterceptor, "post_list_capacity_commitments" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_list_reservations_with_metadata", + "post_list_capacity_commitments_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_list_reservations" + transports.ReservationServiceRestInterceptor, "pre_list_capacity_commitments" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.ListReservationsRequest.pb( - reservation.ListReservationsRequest() + pb_message = reservation.ListCapacityCommitmentsRequest.pb( + reservation.ListCapacityCommitmentsRequest() ) transcode.return_value = { "method": "post", @@ -15636,24 +20772,24 @@ def test_list_reservations_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 = reservation.ListReservationsResponse.to_json( - reservation.ListReservationsResponse() + return_value = reservation.ListCapacityCommitmentsResponse.to_json( + reservation.ListCapacityCommitmentsResponse() ) req.return_value.content = return_value - request = reservation.ListReservationsRequest() + request = reservation.ListCapacityCommitmentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.ListReservationsResponse() + post.return_value = reservation.ListCapacityCommitmentsResponse() post_with_metadata.return_value = ( - reservation.ListReservationsResponse(), + reservation.ListCapacityCommitmentsResponse(), metadata, ) - client.list_reservations( + client.list_capacity_commitments( request, metadata=[ ("key", "val"), @@ -15666,14 +20802,16 @@ def test_list_reservations_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_reservation_rest_bad_request( - request_type=reservation.GetReservationRequest, +def test_get_capacity_commitment_rest_bad_request( + request_type=reservation.GetCapacityCommitmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15688,40 +20826,39 @@ def test_get_reservation_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_reservation(request) + client.get_capacity_commitment(request) @pytest.mark.parametrize( "request_type", [ - reservation.GetReservationRequest, + reservation.GetCapacityCommitmentRequest, dict, ], ) -def test_get_reservation_rest_call_success(request_type): +def test_get_capacity_commitment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/capacityCommitments/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 = reservation.Reservation( + return_value = reservation.CapacityCommitment( name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, multi_region_auxiliary=True, edition=reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + is_flat_rate=True, ) # Wrap the value into a proper Response obj @@ -15729,30 +20866,27 @@ def test_get_reservation_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.Reservation.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_reservation(request) + response = client.get_capacity_commitment(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.Reservation) + assert isinstance(response, reservation.CapacityCommitment) assert response.name == "name_value" - assert response.slot_capacity == 1391 - assert response.ignore_idle_slots is True - assert response.concurrency == 1195 + assert response.slot_count == 1098 + assert response.plan == reservation.CapacityCommitment.CommitmentPlan.FLEX + assert response.state == reservation.CapacityCommitment.State.PENDING + assert response.renewal_plan == reservation.CapacityCommitment.CommitmentPlan.FLEX assert response.multi_region_auxiliary is True assert response.edition == reservation.Edition.STANDARD - assert response.primary_location == "primary_location_value" - assert response.secondary_location == "secondary_location_value" - assert response.original_primary_location == "original_primary_location_value" - assert response.max_slots == 986 - assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert response.is_flat_rate is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_reservation_rest_interceptors(null_interceptor): +def test_get_capacity_commitment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15766,18 +20900,18 @@ def test_get_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_get_reservation" + transports.ReservationServiceRestInterceptor, "post_get_capacity_commitment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_get_reservation_with_metadata", + "post_get_capacity_commitment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_get_reservation" + transports.ReservationServiceRestInterceptor, "pre_get_capacity_commitment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.GetReservationRequest.pb( - reservation.GetReservationRequest() + pb_message = reservation.GetCapacityCommitmentRequest.pb( + reservation.GetCapacityCommitmentRequest() ) transcode.return_value = { "method": "post", @@ -15789,19 +20923,21 @@ def test_get_reservation_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 = reservation.Reservation.to_json(reservation.Reservation()) + return_value = reservation.CapacityCommitment.to_json( + reservation.CapacityCommitment() + ) req.return_value.content = return_value - request = reservation.GetReservationRequest() + request = reservation.GetCapacityCommitmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.Reservation() - post_with_metadata.return_value = reservation.Reservation(), metadata + post.return_value = reservation.CapacityCommitment() + post_with_metadata.return_value = reservation.CapacityCommitment(), metadata - client.get_reservation( + client.get_capacity_commitment( request, metadata=[ ("key", "val"), @@ -15814,14 +20950,16 @@ def test_get_reservation_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_reservation_rest_bad_request( - request_type=reservation.DeleteReservationRequest, +def test_delete_capacity_commitment_rest_bad_request( + request_type=reservation.DeleteCapacityCommitmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15836,23 +20974,25 @@ def test_delete_reservation_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_reservation(request) + client.delete_capacity_commitment(request) @pytest.mark.parametrize( "request_type", [ - reservation.DeleteReservationRequest, + reservation.DeleteCapacityCommitmentRequest, dict, ], ) -def test_delete_reservation_rest_call_success(request_type): +def test_delete_capacity_commitment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -15867,14 +21007,14 @@ def test_delete_reservation_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_reservation(request) + response = client.delete_capacity_commitment(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_reservation_rest_interceptors(null_interceptor): +def test_delete_capacity_commitment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15888,11 +21028,11 @@ def test_delete_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_delete_reservation" + transports.ReservationServiceRestInterceptor, "pre_delete_capacity_commitment" ) as pre: pre.assert_not_called() - pb_message = reservation.DeleteReservationRequest.pb( - reservation.DeleteReservationRequest() + pb_message = reservation.DeleteCapacityCommitmentRequest.pb( + reservation.DeleteCapacityCommitmentRequest() ) transcode.return_value = { "method": "post", @@ -15905,14 +21045,14 @@ def test_delete_reservation_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = reservation.DeleteReservationRequest() + request = reservation.DeleteCapacityCommitmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_reservation( + client.delete_capacity_commitment( request, metadata=[ ("key", "val"), @@ -15923,16 +21063,16 @@ def test_delete_reservation_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_update_reservation_rest_bad_request( - request_type=gcbr_reservation.UpdateReservationRequest, +def test_update_capacity_commitment_rest_bad_request( + request_type=reservation.UpdateCapacityCommitmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "reservation": { - "name": "projects/sample1/locations/sample2/reservations/sample3" + "capacity_commitment": { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" } } request = request_type(**request_init) @@ -15949,64 +21089,57 @@ def test_update_reservation_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_reservation(request) + client.update_capacity_commitment(request) @pytest.mark.parametrize( "request_type", [ - gcbr_reservation.UpdateReservationRequest, + reservation.UpdateCapacityCommitmentRequest, dict, ], ) -def test_update_reservation_rest_call_success(request_type): +def test_update_capacity_commitment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "reservation": { - "name": "projects/sample1/locations/sample2/reservations/sample3" + "capacity_commitment": { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" } } - request_init["reservation"] = { - "name": "projects/sample1/locations/sample2/reservations/sample3", - "slot_capacity": 1391, - "ignore_idle_slots": True, - "autoscale": {"current_slots": 1431, "max_slots": 986}, - "concurrency": 1195, - "creation_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, + request_init["capacity_commitment"] = { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3", + "slot_count": 1098, + "plan": 3, + "state": 1, + "commitment_start_time": {"seconds": 751, "nanos": 543}, + "commitment_end_time": {}, + "failure_status": { + "code": 411, + "message": "message_value", + "details": [ + { + "type_url": "type.googleapis.com/google.protobuf.Duration", + "value": b"\x08\x0c\x10\xdb\x07", + } + ], + }, + "renewal_plan": 3, "multi_region_auxiliary": True, "edition": 1, - "primary_location": "primary_location_value", - "secondary_location": "secondary_location_value", - "original_primary_location": "original_primary_location_value", - "max_slots": 986, - "scaling_mode": 1, - "replication_status": { - "error": { - "code": 411, - "message": "message_value", - "details": [ - { - "type_url": "type.googleapis.com/google.protobuf.Duration", - "value": b"\x08\x0c\x10\xdb\x07", - } - ], - }, - "last_error_time": {}, - "last_replication_time": {}, - "soft_failover_start_time": {}, - }, + "is_flat_rate": 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 = gcbr_reservation.UpdateReservationRequest.meta.fields["reservation"] + test_field = reservation.UpdateCapacityCommitmentRequest.meta.fields[ + "capacity_commitment" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -16034,7 +21167,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["reservation"].items(): # pragma: NO COVER + for field, value in request_init["capacity_commitment"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -16064,27 +21197,24 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["reservation"][field])): - del request_init["reservation"][field][i][subfield] + for i in range(0, len(request_init["capacity_commitment"][field])): + del request_init["capacity_commitment"][field][i][subfield] else: - del request_init["reservation"][field][subfield] + del request_init["capacity_commitment"][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 = gcbr_reservation.Reservation( + return_value = reservation.CapacityCommitment( name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, + slot_count=1098, + plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, + state=reservation.CapacityCommitment.State.PENDING, + renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, multi_region_auxiliary=True, - edition=gcbr_reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, + edition=reservation.Edition.STANDARD, + is_flat_rate=True, ) # Wrap the value into a proper Response obj @@ -16092,32 +21222,27 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = gcbr_reservation.Reservation.pb(return_value) + return_value = reservation.CapacityCommitment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_reservation(request) + response = client.update_capacity_commitment(request) # Establish that the response is the type that we expect. - assert isinstance(response, gcbr_reservation.Reservation) + assert isinstance(response, reservation.CapacityCommitment) assert response.name == "name_value" - assert response.slot_capacity == 1391 - assert response.ignore_idle_slots is True - assert response.concurrency == 1195 + assert response.slot_count == 1098 + assert response.plan == reservation.CapacityCommitment.CommitmentPlan.FLEX + assert response.state == reservation.CapacityCommitment.State.PENDING + assert response.renewal_plan == reservation.CapacityCommitment.CommitmentPlan.FLEX assert response.multi_region_auxiliary is True - assert response.edition == gcbr_reservation.Edition.STANDARD - assert response.primary_location == "primary_location_value" - assert response.secondary_location == "secondary_location_value" - assert response.original_primary_location == "original_primary_location_value" - assert response.max_slots == 986 - assert ( - response.scaling_mode == gcbr_reservation.Reservation.ScalingMode.AUTOSCALE_ONLY - ) + assert response.edition == reservation.Edition.STANDARD + assert response.is_flat_rate is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_reservation_rest_interceptors(null_interceptor): +def test_update_capacity_commitment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16131,18 +21256,18 @@ def test_update_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_update_reservation" + transports.ReservationServiceRestInterceptor, "post_update_capacity_commitment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_update_reservation_with_metadata", + "post_update_capacity_commitment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_update_reservation" + transports.ReservationServiceRestInterceptor, "pre_update_capacity_commitment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = gcbr_reservation.UpdateReservationRequest.pb( - gcbr_reservation.UpdateReservationRequest() + pb_message = reservation.UpdateCapacityCommitmentRequest.pb( + reservation.UpdateCapacityCommitmentRequest() ) transcode.return_value = { "method": "post", @@ -16154,21 +21279,21 @@ def test_update_reservation_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 = gcbr_reservation.Reservation.to_json( - gcbr_reservation.Reservation() + return_value = reservation.CapacityCommitment.to_json( + reservation.CapacityCommitment() ) req.return_value.content = return_value - request = gcbr_reservation.UpdateReservationRequest() + request = reservation.UpdateCapacityCommitmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = gcbr_reservation.Reservation() - post_with_metadata.return_value = gcbr_reservation.Reservation(), metadata + post.return_value = reservation.CapacityCommitment() + post_with_metadata.return_value = reservation.CapacityCommitment(), metadata - client.update_reservation( + client.update_capacity_commitment( request, metadata=[ ("key", "val"), @@ -16181,14 +21306,16 @@ def test_update_reservation_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_failover_reservation_rest_bad_request( - request_type=reservation.FailoverReservationRequest, +def test_split_capacity_commitment_rest_bad_request( + request_type=reservation.SplitCapacityCommitmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16203,71 +21330,50 @@ def test_failover_reservation_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.failover_reservation(request) + client.split_capacity_commitment(request) @pytest.mark.parametrize( "request_type", [ - reservation.FailoverReservationRequest, + reservation.SplitCapacityCommitmentRequest, dict, ], ) -def test_failover_reservation_rest_call_success(request_type): +def test_split_capacity_commitment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "name": "projects/sample1/locations/sample2/capacityCommitments/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 = reservation.Reservation( - name="name_value", - slot_capacity=1391, - ignore_idle_slots=True, - concurrency=1195, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - primary_location="primary_location_value", - secondary_location="secondary_location_value", - original_primary_location="original_primary_location_value", - max_slots=986, - scaling_mode=reservation.Reservation.ScalingMode.AUTOSCALE_ONLY, - ) + return_value = reservation.SplitCapacityCommitmentResponse() # 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 = reservation.Reservation.pb(return_value) + return_value = reservation.SplitCapacityCommitmentResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.failover_reservation(request) + response = client.split_capacity_commitment(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.Reservation) - assert response.name == "name_value" - assert response.slot_capacity == 1391 - assert response.ignore_idle_slots is True - assert response.concurrency == 1195 - assert response.multi_region_auxiliary is True - assert response.edition == reservation.Edition.STANDARD - assert response.primary_location == "primary_location_value" - assert response.secondary_location == "secondary_location_value" - assert response.original_primary_location == "original_primary_location_value" - assert response.max_slots == 986 - assert response.scaling_mode == reservation.Reservation.ScalingMode.AUTOSCALE_ONLY + assert isinstance(response, reservation.SplitCapacityCommitmentResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_failover_reservation_rest_interceptors(null_interceptor): +def test_split_capacity_commitment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16281,18 +21387,18 @@ def test_failover_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_failover_reservation" + transports.ReservationServiceRestInterceptor, "post_split_capacity_commitment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_failover_reservation_with_metadata", + "post_split_capacity_commitment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_failover_reservation" + transports.ReservationServiceRestInterceptor, "pre_split_capacity_commitment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.FailoverReservationRequest.pb( - reservation.FailoverReservationRequest() + pb_message = reservation.SplitCapacityCommitmentRequest.pb( + reservation.SplitCapacityCommitmentRequest() ) transcode.return_value = { "method": "post", @@ -16304,19 +21410,24 @@ def test_failover_reservation_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 = reservation.Reservation.to_json(reservation.Reservation()) + return_value = reservation.SplitCapacityCommitmentResponse.to_json( + reservation.SplitCapacityCommitmentResponse() + ) req.return_value.content = return_value - request = reservation.FailoverReservationRequest() + request = reservation.SplitCapacityCommitmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.Reservation() - post_with_metadata.return_value = reservation.Reservation(), metadata + post.return_value = reservation.SplitCapacityCommitmentResponse() + post_with_metadata.return_value = ( + reservation.SplitCapacityCommitmentResponse(), + metadata, + ) - client.failover_reservation( + client.split_capacity_commitment( request, metadata=[ ("key", "val"), @@ -16329,8 +21440,8 @@ def test_failover_reservation_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_capacity_commitment_rest_bad_request( - request_type=reservation.CreateCapacityCommitmentRequest, +def test_merge_capacity_commitments_rest_bad_request( + request_type=reservation.MergeCapacityCommitmentsRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -16351,114 +21462,23 @@ def test_create_capacity_commitment_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_capacity_commitment(request) + client.merge_capacity_commitments(request) @pytest.mark.parametrize( "request_type", [ - reservation.CreateCapacityCommitmentRequest, + reservation.MergeCapacityCommitmentsRequest, dict, ], ) -def test_create_capacity_commitment_rest_call_success(request_type): +def test_merge_capacity_commitments_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = {"parent": "projects/sample1/locations/sample2"} - request_init["capacity_commitment"] = { - "name": "name_value", - "slot_count": 1098, - "plan": 3, - "state": 1, - "commitment_start_time": {"seconds": 751, "nanos": 543}, - "commitment_end_time": {}, - "failure_status": { - "code": 411, - "message": "message_value", - "details": [ - { - "type_url": "type.googleapis.com/google.protobuf.Duration", - "value": b"\x08\x0c\x10\xdb\x07", - } - ], - }, - "renewal_plan": 3, - "multi_region_auxiliary": True, - "edition": 1, - "is_flat_rate": 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 = reservation.CreateCapacityCommitmentRequest.meta.fields[ - "capacity_commitment" - ] - - 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["capacity_commitment"].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["capacity_commitment"][field])): - del request_init["capacity_commitment"][field][i][subfield] - else: - del request_init["capacity_commitment"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -16485,7 +21505,7 @@ def get_message_fields(field): response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.create_capacity_commitment(request) + response = client.merge_capacity_commitments(request) # Establish that the response is the type that we expect. assert isinstance(response, reservation.CapacityCommitment) @@ -16500,7 +21520,7 @@ def get_message_fields(field): @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_capacity_commitment_rest_interceptors(null_interceptor): +def test_merge_capacity_commitments_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16514,18 +21534,18 @@ def test_create_capacity_commitment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_create_capacity_commitment" + transports.ReservationServiceRestInterceptor, "post_merge_capacity_commitments" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_create_capacity_commitment_with_metadata", + "post_merge_capacity_commitments_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_create_capacity_commitment" + transports.ReservationServiceRestInterceptor, "pre_merge_capacity_commitments" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.CreateCapacityCommitmentRequest.pb( - reservation.CreateCapacityCommitmentRequest() + pb_message = reservation.MergeCapacityCommitmentsRequest.pb( + reservation.MergeCapacityCommitmentsRequest() ) transcode.return_value = { "method": "post", @@ -16542,7 +21562,7 @@ def test_create_capacity_commitment_rest_interceptors(null_interceptor): ) req.return_value.content = return_value - request = reservation.CreateCapacityCommitmentRequest() + request = reservation.MergeCapacityCommitmentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -16551,7 +21571,7 @@ def test_create_capacity_commitment_rest_interceptors(null_interceptor): post.return_value = reservation.CapacityCommitment() post_with_metadata.return_value = reservation.CapacityCommitment(), metadata - client.create_capacity_commitment( + client.merge_capacity_commitments( request, metadata=[ ("key", "val"), @@ -16564,14 +21584,14 @@ def test_create_capacity_commitment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_capacity_commitments_rest_bad_request( - request_type=reservation.ListCapacityCommitmentsRequest, +def test_create_assignment_rest_bad_request( + request_type=reservation.CreateAssignmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16586,30 +21606,109 @@ def test_list_capacity_commitments_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_capacity_commitments(request) + client.create_assignment(request) @pytest.mark.parametrize( "request_type", [ - reservation.ListCapacityCommitmentsRequest, + reservation.CreateAssignmentRequest, dict, ], ) -def test_list_capacity_commitments_rest_call_success(request_type): +def test_create_assignment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} + request_init["assignment"] = { + "name": "name_value", + "assignee": "assignee_value", + "job_type": 1, + "state": 1, + "enable_gemini_in_bigquery": True, + "scheduling_policy": {"concurrency": 1195, "max_slots": 986}, + } + # 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 = reservation.CreateAssignmentRequest.meta.fields["assignment"] + + 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["assignment"].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["assignment"][field])): + del request_init["assignment"][field][i][subfield] + else: + del request_init["assignment"][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 = reservation.ListCapacityCommitmentsResponse( - next_page_token="next_page_token_value", + return_value = reservation.Assignment( + name="name_value", + assignee="assignee_value", + job_type=reservation.Assignment.JobType.PIPELINE, + state=reservation.Assignment.State.PENDING, + enable_gemini_in_bigquery=True, ) # Wrap the value into a proper Response obj @@ -16617,20 +21716,24 @@ def test_list_capacity_commitments_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.ListCapacityCommitmentsResponse.pb(return_value) + return_value = reservation.Assignment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_capacity_commitments(request) + response = client.create_assignment(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListCapacityCommitmentsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, reservation.Assignment) + assert response.name == "name_value" + assert response.assignee == "assignee_value" + assert response.job_type == reservation.Assignment.JobType.PIPELINE + assert response.state == reservation.Assignment.State.PENDING + assert response.enable_gemini_in_bigquery is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_capacity_commitments_rest_interceptors(null_interceptor): +def test_create_assignment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16644,18 +21747,18 @@ def test_list_capacity_commitments_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_list_capacity_commitments" + transports.ReservationServiceRestInterceptor, "post_create_assignment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_list_capacity_commitments_with_metadata", + "post_create_assignment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_list_capacity_commitments" + transports.ReservationServiceRestInterceptor, "pre_create_assignment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.ListCapacityCommitmentsRequest.pb( - reservation.ListCapacityCommitmentsRequest() + pb_message = reservation.CreateAssignmentRequest.pb( + reservation.CreateAssignmentRequest() ) transcode.return_value = { "method": "post", @@ -16667,24 +21770,19 @@ def test_list_capacity_commitments_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 = reservation.ListCapacityCommitmentsResponse.to_json( - reservation.ListCapacityCommitmentsResponse() - ) + return_value = reservation.Assignment.to_json(reservation.Assignment()) req.return_value.content = return_value - request = reservation.ListCapacityCommitmentsRequest() + request = reservation.CreateAssignmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.ListCapacityCommitmentsResponse() - post_with_metadata.return_value = ( - reservation.ListCapacityCommitmentsResponse(), - metadata, - ) + post.return_value = reservation.Assignment() + post_with_metadata.return_value = reservation.Assignment(), metadata - client.list_capacity_commitments( + client.create_assignment( request, metadata=[ ("key", "val"), @@ -16697,16 +21795,14 @@ def test_list_capacity_commitments_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_capacity_commitment_rest_bad_request( - request_type=reservation.GetCapacityCommitmentRequest, +def test_list_assignments_rest_bad_request( + request_type=reservation.ListAssignmentsRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } + request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16721,39 +21817,30 @@ def test_get_capacity_commitment_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_capacity_commitment(request) + client.list_assignments(request) @pytest.mark.parametrize( "request_type", [ - reservation.GetCapacityCommitmentRequest, + reservation.ListAssignmentsRequest, dict, ], ) -def test_get_capacity_commitment_rest_call_success(request_type): +def test_list_assignments_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } + request_init = {"parent": "projects/sample1/locations/sample2/reservations/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 = reservation.CapacityCommitment( - name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, + return_value = reservation.ListAssignmentsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -16761,27 +21848,20 @@ def test_get_capacity_commitment_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.CapacityCommitment.pb(return_value) + return_value = reservation.ListAssignmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_capacity_commitment(request) + response = client.list_assignments(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.CapacityCommitment) - assert response.name == "name_value" - assert response.slot_count == 1098 - assert response.plan == reservation.CapacityCommitment.CommitmentPlan.FLEX - assert response.state == reservation.CapacityCommitment.State.PENDING - assert response.renewal_plan == reservation.CapacityCommitment.CommitmentPlan.FLEX - assert response.multi_region_auxiliary is True - assert response.edition == reservation.Edition.STANDARD - assert response.is_flat_rate is True + assert isinstance(response, pagers.ListAssignmentsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_capacity_commitment_rest_interceptors(null_interceptor): +def test_list_assignments_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16795,18 +21875,18 @@ def test_get_capacity_commitment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_get_capacity_commitment" + transports.ReservationServiceRestInterceptor, "post_list_assignments" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_get_capacity_commitment_with_metadata", + "post_list_assignments_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_get_capacity_commitment" + transports.ReservationServiceRestInterceptor, "pre_list_assignments" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.GetCapacityCommitmentRequest.pb( - reservation.GetCapacityCommitmentRequest() + pb_message = reservation.ListAssignmentsRequest.pb( + reservation.ListAssignmentsRequest() ) transcode.return_value = { "method": "post", @@ -16818,21 +21898,24 @@ def test_get_capacity_commitment_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 = reservation.CapacityCommitment.to_json( - reservation.CapacityCommitment() + return_value = reservation.ListAssignmentsResponse.to_json( + reservation.ListAssignmentsResponse() ) req.return_value.content = return_value - request = reservation.GetCapacityCommitmentRequest() + request = reservation.ListAssignmentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.CapacityCommitment() - post_with_metadata.return_value = reservation.CapacityCommitment(), metadata + post.return_value = reservation.ListAssignmentsResponse() + post_with_metadata.return_value = ( + reservation.ListAssignmentsResponse(), + metadata, + ) - client.get_capacity_commitment( + client.list_assignments( request, metadata=[ ("key", "val"), @@ -16845,15 +21928,15 @@ def test_get_capacity_commitment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_capacity_commitment_rest_bad_request( - request_type=reservation.DeleteCapacityCommitmentRequest, +def test_delete_assignment_rest_bad_request( + request_type=reservation.DeleteAssignmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" } request = request_type(**request_init) @@ -16869,24 +21952,24 @@ def test_delete_capacity_commitment_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_capacity_commitment(request) + client.delete_assignment(request) @pytest.mark.parametrize( "request_type", [ - reservation.DeleteCapacityCommitmentRequest, + reservation.DeleteAssignmentRequest, dict, ], ) -def test_delete_capacity_commitment_rest_call_success(request_type): +def test_delete_assignment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" } request = request_type(**request_init) @@ -16902,14 +21985,14 @@ def test_delete_capacity_commitment_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_capacity_commitment(request) + response = client.delete_assignment(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_capacity_commitment_rest_interceptors(null_interceptor): +def test_delete_assignment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16923,11 +22006,11 @@ def test_delete_capacity_commitment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_delete_capacity_commitment" + transports.ReservationServiceRestInterceptor, "pre_delete_assignment" ) as pre: pre.assert_not_called() - pb_message = reservation.DeleteCapacityCommitmentRequest.pb( - reservation.DeleteCapacityCommitmentRequest() + pb_message = reservation.DeleteAssignmentRequest.pb( + reservation.DeleteAssignmentRequest() ) transcode.return_value = { "method": "post", @@ -16940,14 +22023,14 @@ def test_delete_capacity_commitment_rest_interceptors(null_interceptor): req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - request = reservation.DeleteCapacityCommitmentRequest() + request = reservation.DeleteAssignmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - client.delete_capacity_commitment( + client.delete_assignment( request, metadata=[ ("key", "val"), @@ -16958,158 +22041,52 @@ def test_delete_capacity_commitment_rest_interceptors(null_interceptor): pre.assert_called_once() -def test_update_capacity_commitment_rest_bad_request( - request_type=reservation.UpdateCapacityCommitmentRequest, -): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - # send a request that will satisfy transcoding - request_init = { - "capacity_commitment": { - "name": "projects/sample1/locations/sample2/capacityCommitments/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_capacity_commitment(request) - - -@pytest.mark.parametrize( - "request_type", - [ - reservation.UpdateCapacityCommitmentRequest, - dict, - ], -) -def test_update_capacity_commitment_rest_call_success(request_type): - client = ReservationServiceClient( - credentials=ga_credentials.AnonymousCredentials(), transport="rest" - ) - - # send a request that will satisfy transcoding - request_init = { - "capacity_commitment": { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } - } - request_init["capacity_commitment"] = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3", - "slot_count": 1098, - "plan": 3, - "state": 1, - "commitment_start_time": {"seconds": 751, "nanos": 543}, - "commitment_end_time": {}, - "failure_status": { - "code": 411, - "message": "message_value", - "details": [ - { - "type_url": "type.googleapis.com/google.protobuf.Duration", - "value": b"\x08\x0c\x10\xdb\x07", - } - ], - }, - "renewal_plan": 3, - "multi_region_auxiliary": True, - "edition": 1, - "is_flat_rate": 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 = reservation.UpdateCapacityCommitmentRequest.meta.fields[ - "capacity_commitment" - ] - - 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_search_assignments_rest_bad_request( + request_type=reservation.SearchAssignmentsRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) - 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.search_assignments(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["capacity_commitment"].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", + [ + reservation.SearchAssignmentsRequest, + dict, + ], +) +def test_search_assignments_rest_call_success(request_type): + client = ReservationServiceClient( + 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["capacity_commitment"][field])): - del request_init["capacity_commitment"][field][i][subfield] - else: - del request_init["capacity_commitment"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = reservation.CapacityCommitment( - name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, + return_value = reservation.SearchAssignmentsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -17117,27 +22094,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.CapacityCommitment.pb(return_value) + return_value = reservation.SearchAssignmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_capacity_commitment(request) + response = client.search_assignments(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.CapacityCommitment) - assert response.name == "name_value" - assert response.slot_count == 1098 - assert response.plan == reservation.CapacityCommitment.CommitmentPlan.FLEX - assert response.state == reservation.CapacityCommitment.State.PENDING - assert response.renewal_plan == reservation.CapacityCommitment.CommitmentPlan.FLEX - assert response.multi_region_auxiliary is True - assert response.edition == reservation.Edition.STANDARD - assert response.is_flat_rate is True + assert isinstance(response, pagers.SearchAssignmentsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_capacity_commitment_rest_interceptors(null_interceptor): +def test_search_assignments_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17151,18 +22121,18 @@ def test_update_capacity_commitment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_update_capacity_commitment" + transports.ReservationServiceRestInterceptor, "post_search_assignments" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_update_capacity_commitment_with_metadata", + "post_search_assignments_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_update_capacity_commitment" + transports.ReservationServiceRestInterceptor, "pre_search_assignments" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.UpdateCapacityCommitmentRequest.pb( - reservation.UpdateCapacityCommitmentRequest() + pb_message = reservation.SearchAssignmentsRequest.pb( + reservation.SearchAssignmentsRequest() ) transcode.return_value = { "method": "post", @@ -17174,21 +22144,24 @@ def test_update_capacity_commitment_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 = reservation.CapacityCommitment.to_json( - reservation.CapacityCommitment() + return_value = reservation.SearchAssignmentsResponse.to_json( + reservation.SearchAssignmentsResponse() ) req.return_value.content = return_value - request = reservation.UpdateCapacityCommitmentRequest() + request = reservation.SearchAssignmentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.CapacityCommitment() - post_with_metadata.return_value = reservation.CapacityCommitment(), metadata + post.return_value = reservation.SearchAssignmentsResponse() + post_with_metadata.return_value = ( + reservation.SearchAssignmentsResponse(), + metadata, + ) - client.update_capacity_commitment( + client.search_assignments( request, metadata=[ ("key", "val"), @@ -17201,16 +22174,14 @@ def test_update_capacity_commitment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_split_capacity_commitment_rest_bad_request( - request_type=reservation.SplitCapacityCommitmentRequest, +def test_search_all_assignments_rest_bad_request( + request_type=reservation.SearchAllAssignmentsRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17225,50 +22196,51 @@ def test_split_capacity_commitment_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.split_capacity_commitment(request) + client.search_all_assignments(request) @pytest.mark.parametrize( "request_type", [ - reservation.SplitCapacityCommitmentRequest, + reservation.SearchAllAssignmentsRequest, dict, ], ) -def test_split_capacity_commitment_rest_call_success(request_type): +def test_search_all_assignments_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/locations/sample2/capacityCommitments/sample3" - } + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = reservation.SplitCapacityCommitmentResponse() + return_value = reservation.SearchAllAssignmentsResponse( + 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 = reservation.SplitCapacityCommitmentResponse.pb(return_value) + return_value = reservation.SearchAllAssignmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.split_capacity_commitment(request) + response = client.search_all_assignments(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.SplitCapacityCommitmentResponse) + assert isinstance(response, pagers.SearchAllAssignmentsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_split_capacity_commitment_rest_interceptors(null_interceptor): +def test_search_all_assignments_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17282,18 +22254,18 @@ def test_split_capacity_commitment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_split_capacity_commitment" + transports.ReservationServiceRestInterceptor, "post_search_all_assignments" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_split_capacity_commitment_with_metadata", + "post_search_all_assignments_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_split_capacity_commitment" + transports.ReservationServiceRestInterceptor, "pre_search_all_assignments" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.SplitCapacityCommitmentRequest.pb( - reservation.SplitCapacityCommitmentRequest() + pb_message = reservation.SearchAllAssignmentsRequest.pb( + reservation.SearchAllAssignmentsRequest() ) transcode.return_value = { "method": "post", @@ -17305,24 +22277,24 @@ def test_split_capacity_commitment_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 = reservation.SplitCapacityCommitmentResponse.to_json( - reservation.SplitCapacityCommitmentResponse() + return_value = reservation.SearchAllAssignmentsResponse.to_json( + reservation.SearchAllAssignmentsResponse() ) req.return_value.content = return_value - request = reservation.SplitCapacityCommitmentRequest() + request = reservation.SearchAllAssignmentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.SplitCapacityCommitmentResponse() + post.return_value = reservation.SearchAllAssignmentsResponse() post_with_metadata.return_value = ( - reservation.SplitCapacityCommitmentResponse(), + reservation.SearchAllAssignmentsResponse(), metadata, ) - client.split_capacity_commitment( + client.search_all_assignments( request, metadata=[ ("key", "val"), @@ -17335,14 +22307,16 @@ def test_split_capacity_commitment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_merge_capacity_commitments_rest_bad_request( - request_type=reservation.MergeCapacityCommitmentsRequest, +def test_move_assignment_rest_bad_request( + request_type=reservation.MoveAssignmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17357,37 +22331,36 @@ def test_merge_capacity_commitments_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.merge_capacity_commitments(request) + client.move_assignment(request) @pytest.mark.parametrize( "request_type", [ - reservation.MergeCapacityCommitmentsRequest, + reservation.MoveAssignmentRequest, dict, ], ) -def test_merge_capacity_commitments_rest_call_success(request_type): +def test_move_assignment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = reservation.CapacityCommitment( + return_value = reservation.Assignment( name="name_value", - slot_count=1098, - plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - state=reservation.CapacityCommitment.State.PENDING, - renewal_plan=reservation.CapacityCommitment.CommitmentPlan.FLEX, - multi_region_auxiliary=True, - edition=reservation.Edition.STANDARD, - is_flat_rate=True, + assignee="assignee_value", + job_type=reservation.Assignment.JobType.PIPELINE, + state=reservation.Assignment.State.PENDING, + enable_gemini_in_bigquery=True, ) # Wrap the value into a proper Response obj @@ -17395,27 +22368,24 @@ def test_merge_capacity_commitments_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.CapacityCommitment.pb(return_value) + return_value = reservation.Assignment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.merge_capacity_commitments(request) + response = client.move_assignment(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.CapacityCommitment) + assert isinstance(response, reservation.Assignment) assert response.name == "name_value" - assert response.slot_count == 1098 - assert response.plan == reservation.CapacityCommitment.CommitmentPlan.FLEX - assert response.state == reservation.CapacityCommitment.State.PENDING - assert response.renewal_plan == reservation.CapacityCommitment.CommitmentPlan.FLEX - assert response.multi_region_auxiliary is True - assert response.edition == reservation.Edition.STANDARD - assert response.is_flat_rate is True + assert response.assignee == "assignee_value" + assert response.job_type == reservation.Assignment.JobType.PIPELINE + assert response.state == reservation.Assignment.State.PENDING + assert response.enable_gemini_in_bigquery is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_merge_capacity_commitments_rest_interceptors(null_interceptor): +def test_move_assignment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17429,18 +22399,18 @@ def test_merge_capacity_commitments_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_merge_capacity_commitments" + transports.ReservationServiceRestInterceptor, "post_move_assignment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_merge_capacity_commitments_with_metadata", + "post_move_assignment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_merge_capacity_commitments" + transports.ReservationServiceRestInterceptor, "pre_move_assignment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.MergeCapacityCommitmentsRequest.pb( - reservation.MergeCapacityCommitmentsRequest() + pb_message = reservation.MoveAssignmentRequest.pb( + reservation.MoveAssignmentRequest() ) transcode.return_value = { "method": "post", @@ -17452,21 +22422,19 @@ def test_merge_capacity_commitments_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 = reservation.CapacityCommitment.to_json( - reservation.CapacityCommitment() - ) + return_value = reservation.Assignment.to_json(reservation.Assignment()) req.return_value.content = return_value - request = reservation.MergeCapacityCommitmentsRequest() + request = reservation.MoveAssignmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.CapacityCommitment() - post_with_metadata.return_value = reservation.CapacityCommitment(), metadata + post.return_value = reservation.Assignment() + post_with_metadata.return_value = reservation.Assignment(), metadata - client.merge_capacity_commitments( + client.move_assignment( request, metadata=[ ("key", "val"), @@ -17479,14 +22447,18 @@ def test_merge_capacity_commitments_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_assignment_rest_bad_request( - request_type=reservation.CreateAssignmentRequest, +def test_update_assignment_rest_bad_request( + request_type=reservation.UpdateAssignmentRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "assignment": { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17501,36 +22473,41 @@ def test_create_assignment_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_assignment(request) + client.update_assignment(request) @pytest.mark.parametrize( "request_type", [ - reservation.CreateAssignmentRequest, + reservation.UpdateAssignmentRequest, dict, ], ) -def test_create_assignment_rest_call_success(request_type): +def test_update_assignment_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = { + "assignment": { + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + } + } request_init["assignment"] = { - "name": "name_value", + "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4", "assignee": "assignee_value", "job_type": 1, "state": 1, "enable_gemini_in_bigquery": True, + "scheduling_policy": {"concurrency": 1195, "max_slots": 986}, } # 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 = reservation.CreateAssignmentRequest.meta.fields["assignment"] + test_field = reservation.UpdateAssignmentRequest.meta.fields["assignment"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -17615,7 +22592,7 @@ def get_message_fields(field): response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.create_assignment(request) + response = client.update_assignment(request) # Establish that the response is the type that we expect. assert isinstance(response, reservation.Assignment) @@ -17627,7 +22604,7 @@ def get_message_fields(field): @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_assignment_rest_interceptors(null_interceptor): +def test_update_assignment_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17641,18 +22618,18 @@ def test_create_assignment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_create_assignment" + transports.ReservationServiceRestInterceptor, "post_update_assignment" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_create_assignment_with_metadata", + "post_update_assignment_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_create_assignment" + transports.ReservationServiceRestInterceptor, "pre_update_assignment" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.CreateAssignmentRequest.pb( - reservation.CreateAssignmentRequest() + pb_message = reservation.UpdateAssignmentRequest.pb( + reservation.UpdateAssignmentRequest() ) transcode.return_value = { "method": "post", @@ -17667,7 +22644,7 @@ def test_create_assignment_rest_interceptors(null_interceptor): return_value = reservation.Assignment.to_json(reservation.Assignment()) req.return_value.content = return_value - request = reservation.CreateAssignmentRequest() + request = reservation.UpdateAssignmentRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -17676,7 +22653,7 @@ def test_create_assignment_rest_interceptors(null_interceptor): post.return_value = reservation.Assignment() post_with_metadata.return_value = reservation.Assignment(), metadata - client.create_assignment( + client.update_assignment( request, metadata=[ ("key", "val"), @@ -17689,14 +22666,14 @@ def test_create_assignment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_assignments_rest_bad_request( - request_type=reservation.ListAssignmentsRequest, +def test_get_bi_reservation_rest_bad_request( + request_type=reservation.GetBiReservationRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = {"name": "projects/sample1/locations/sample2/biReservation"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17711,30 +22688,31 @@ def test_list_assignments_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_assignments(request) + client.get_bi_reservation(request) @pytest.mark.parametrize( "request_type", [ - reservation.ListAssignmentsRequest, + reservation.GetBiReservationRequest, dict, ], ) -def test_list_assignments_rest_call_success(request_type): +def test_get_bi_reservation_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2/reservations/sample3"} + request_init = {"name": "projects/sample1/locations/sample2/biReservation"} 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 = reservation.ListAssignmentsResponse( - next_page_token="next_page_token_value", + return_value = reservation.BiReservation( + name="name_value", + size=443, ) # Wrap the value into a proper Response obj @@ -17742,20 +22720,21 @@ def test_list_assignments_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.ListAssignmentsResponse.pb(return_value) + return_value = reservation.BiReservation.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_assignments(request) + response = client.get_bi_reservation(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListAssignmentsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, reservation.BiReservation) + assert response.name == "name_value" + assert response.size == 443 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_assignments_rest_interceptors(null_interceptor): +def test_get_bi_reservation_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17769,18 +22748,18 @@ def test_list_assignments_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_list_assignments" + transports.ReservationServiceRestInterceptor, "post_get_bi_reservation" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_list_assignments_with_metadata", + "post_get_bi_reservation_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_list_assignments" + transports.ReservationServiceRestInterceptor, "pre_get_bi_reservation" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.ListAssignmentsRequest.pb( - reservation.ListAssignmentsRequest() + pb_message = reservation.GetBiReservationRequest.pb( + reservation.GetBiReservationRequest() ) transcode.return_value = { "method": "post", @@ -17792,24 +22771,19 @@ def test_list_assignments_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 = reservation.ListAssignmentsResponse.to_json( - reservation.ListAssignmentsResponse() - ) + return_value = reservation.BiReservation.to_json(reservation.BiReservation()) req.return_value.content = return_value - request = reservation.ListAssignmentsRequest() + request = reservation.GetBiReservationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.ListAssignmentsResponse() - post_with_metadata.return_value = ( - reservation.ListAssignmentsResponse(), - metadata, - ) + post.return_value = reservation.BiReservation() + post_with_metadata.return_value = reservation.BiReservation(), metadata - client.list_assignments( + client.get_bi_reservation( request, metadata=[ ("key", "val"), @@ -17822,15 +22796,15 @@ def test_list_assignments_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_assignment_rest_bad_request( - request_type=reservation.DeleteAssignmentRequest, +def test_update_bi_reservation_rest_bad_request( + request_type=reservation.UpdateBiReservationRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + "bi_reservation": {"name": "projects/sample1/locations/sample2/biReservation"} } request = request_type(**request_init) @@ -17846,47 +22820,134 @@ def test_delete_assignment_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_assignment(request) + client.update_bi_reservation(request) @pytest.mark.parametrize( "request_type", [ - reservation.DeleteAssignmentRequest, + reservation.UpdateBiReservationRequest, dict, ], ) -def test_delete_assignment_rest_call_success(request_type): +def test_update_bi_reservation_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + "bi_reservation": {"name": "projects/sample1/locations/sample2/biReservation"} + } + request_init["bi_reservation"] = { + "name": "projects/sample1/locations/sample2/biReservation", + "update_time": {"seconds": 751, "nanos": 543}, + "size": 443, + "preferred_tables": [ + { + "project_id": "project_id_value", + "dataset_id": "dataset_id_value", + "table_id": "table_id_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 = reservation.UpdateBiReservationRequest.meta.fields["bi_reservation"] + + 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["bi_reservation"].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["bi_reservation"][field])): + del request_init["bi_reservation"][field][i][subfield] + else: + del request_init["bi_reservation"][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 = reservation.BiReservation( + name="name_value", + size=443, + ) # 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 = reservation.BiReservation.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_assignment(request) + response = client.update_bi_reservation(request) # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, reservation.BiReservation) + assert response.name == "name_value" + assert response.size == 443 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_assignment_rest_interceptors(null_interceptor): +def test_update_bi_reservation_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17900,11 +22961,18 @@ def test_delete_assignment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_delete_assignment" + transports.ReservationServiceRestInterceptor, "post_update_bi_reservation" + ) as post, mock.patch.object( + transports.ReservationServiceRestInterceptor, + "post_update_bi_reservation_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.ReservationServiceRestInterceptor, "pre_update_bi_reservation" ) as pre: pre.assert_not_called() - pb_message = reservation.DeleteAssignmentRequest.pb( - reservation.DeleteAssignmentRequest() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = reservation.UpdateBiReservationRequest.pb( + reservation.UpdateBiReservationRequest() ) transcode.return_value = { "method": "post", @@ -17916,15 +22984,19 @@ def test_delete_assignment_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 = reservation.BiReservation.to_json(reservation.BiReservation()) + req.return_value.content = return_value - request = reservation.DeleteAssignmentRequest() + request = reservation.UpdateBiReservationRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = reservation.BiReservation() + post_with_metadata.return_value = reservation.BiReservation(), metadata - client.delete_assignment( + client.update_bi_reservation( request, metadata=[ ("key", "val"), @@ -17933,16 +23005,20 @@ def test_delete_assignment_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_search_assignments_rest_bad_request( - request_type=reservation.SearchAssignmentsRequest, +def test_get_iam_policy_rest_bad_request( + request_type=iam_policy_pb2.GetIamPolicyRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "resource": "projects/sample1/locations/sample2/reservations/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17957,51 +23033,52 @@ def test_search_assignments_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_assignments(request) + client.get_iam_policy(request) @pytest.mark.parametrize( "request_type", [ - reservation.SearchAssignmentsRequest, + iam_policy_pb2.GetIamPolicyRequest, dict, ], ) -def test_search_assignments_rest_call_success(request_type): +def test_get_iam_policy_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "resource": "projects/sample1/locations/sample2/reservations/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 = reservation.SearchAssignmentsResponse( - next_page_token="next_page_token_value", + return_value = policy_pb2.Policy( + version=774, + etag=b"etag_blob", ) # 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 = reservation.SearchAssignmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_assignments(request) + response = client.get_iam_policy(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.SearchAssignmentsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, policy_pb2.Policy) + assert response.version == 774 + assert response.etag == b"etag_blob" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_search_assignments_rest_interceptors(null_interceptor): +def test_get_iam_policy_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18015,19 +23092,17 @@ def test_search_assignments_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_search_assignments" + transports.ReservationServiceRestInterceptor, "post_get_iam_policy" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_search_assignments_with_metadata", + "post_get_iam_policy_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_search_assignments" + transports.ReservationServiceRestInterceptor, "pre_get_iam_policy" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.SearchAssignmentsRequest.pb( - reservation.SearchAssignmentsRequest() - ) + pb_message = iam_policy_pb2.GetIamPolicyRequest() transcode.return_value = { "method": "post", "uri": "my_uri", @@ -18036,26 +23111,21 @@ def test_search_assignments_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 = reservation.SearchAssignmentsResponse.to_json( - reservation.SearchAssignmentsResponse() - ) + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(policy_pb2.Policy()) req.return_value.content = return_value - request = reservation.SearchAssignmentsRequest() + request = iam_policy_pb2.GetIamPolicyRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.SearchAssignmentsResponse() - post_with_metadata.return_value = ( - reservation.SearchAssignmentsResponse(), - metadata, - ) + post.return_value = policy_pb2.Policy() + post_with_metadata.return_value = policy_pb2.Policy(), metadata - client.search_assignments( + client.get_iam_policy( request, metadata=[ ("key", "val"), @@ -18068,14 +23138,16 @@ def test_search_assignments_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_search_all_assignments_rest_bad_request( - request_type=reservation.SearchAllAssignmentsRequest, +def test_set_iam_policy_rest_bad_request( + request_type=iam_policy_pb2.SetIamPolicyRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "resource": "projects/sample1/locations/sample2/reservations/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -18090,51 +23162,52 @@ def test_search_all_assignments_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_all_assignments(request) + client.set_iam_policy(request) @pytest.mark.parametrize( "request_type", [ - reservation.SearchAllAssignmentsRequest, + iam_policy_pb2.SetIamPolicyRequest, dict, ], ) -def test_search_all_assignments_rest_call_success(request_type): +def test_set_iam_policy_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} + request_init = { + "resource": "projects/sample1/locations/sample2/reservations/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 = reservation.SearchAllAssignmentsResponse( - next_page_token="next_page_token_value", + return_value = policy_pb2.Policy( + version=774, + etag=b"etag_blob", ) # 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 = reservation.SearchAllAssignmentsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_all_assignments(request) + response = client.set_iam_policy(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.SearchAllAssignmentsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, policy_pb2.Policy) + assert response.version == 774 + assert response.etag == b"etag_blob" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_search_all_assignments_rest_interceptors(null_interceptor): +def test_set_iam_policy_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18148,19 +23221,17 @@ def test_search_all_assignments_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_search_all_assignments" + transports.ReservationServiceRestInterceptor, "post_set_iam_policy" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_search_all_assignments_with_metadata", + "post_set_iam_policy_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_search_all_assignments" + transports.ReservationServiceRestInterceptor, "pre_set_iam_policy" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.SearchAllAssignmentsRequest.pb( - reservation.SearchAllAssignmentsRequest() - ) + pb_message = iam_policy_pb2.SetIamPolicyRequest() transcode.return_value = { "method": "post", "uri": "my_uri", @@ -18171,24 +23242,19 @@ def test_search_all_assignments_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 = reservation.SearchAllAssignmentsResponse.to_json( - reservation.SearchAllAssignmentsResponse() - ) + return_value = json_format.MessageToJson(policy_pb2.Policy()) req.return_value.content = return_value - request = reservation.SearchAllAssignmentsRequest() + request = iam_policy_pb2.SetIamPolicyRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.SearchAllAssignmentsResponse() - post_with_metadata.return_value = ( - reservation.SearchAllAssignmentsResponse(), - metadata, - ) + post.return_value = policy_pb2.Policy() + post_with_metadata.return_value = policy_pb2.Policy(), metadata - client.search_all_assignments( + client.set_iam_policy( request, metadata=[ ("key", "val"), @@ -18201,15 +23267,15 @@ def test_search_all_assignments_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_move_assignment_rest_bad_request( - request_type=reservation.MoveAssignmentRequest, +def test_test_iam_permissions_rest_bad_request( + request_type=iam_policy_pb2.TestIamPermissionsRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + "resource": "projects/sample1/locations/sample2/reservations/sample3" } request = request_type(**request_init) @@ -18225,61 +23291,50 @@ def test_move_assignment_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.move_assignment(request) + client.test_iam_permissions(request) @pytest.mark.parametrize( "request_type", [ - reservation.MoveAssignmentRequest, + iam_policy_pb2.TestIamPermissionsRequest, dict, ], ) -def test_move_assignment_rest_call_success(request_type): +def test_test_iam_permissions_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" + "resource": "projects/sample1/locations/sample2/reservations/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 = reservation.Assignment( - name="name_value", - assignee="assignee_value", - job_type=reservation.Assignment.JobType.PIPELINE, - state=reservation.Assignment.State.PENDING, - enable_gemini_in_bigquery=True, + return_value = iam_policy_pb2.TestIamPermissionsResponse( + permissions=["permissions_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 = reservation.Assignment.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.move_assignment(request) + response = client.test_iam_permissions(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.Assignment) - assert response.name == "name_value" - assert response.assignee == "assignee_value" - assert response.job_type == reservation.Assignment.JobType.PIPELINE - assert response.state == reservation.Assignment.State.PENDING - assert response.enable_gemini_in_bigquery is True + assert isinstance(response, iam_policy_pb2.TestIamPermissionsResponse) + assert response.permissions == ["permissions_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_move_assignment_rest_interceptors(null_interceptor): +def test_test_iam_permissions_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18293,19 +23348,17 @@ def test_move_assignment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_move_assignment" + transports.ReservationServiceRestInterceptor, "post_test_iam_permissions" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_move_assignment_with_metadata", + "post_test_iam_permissions_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_move_assignment" + transports.ReservationServiceRestInterceptor, "pre_test_iam_permissions" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.MoveAssignmentRequest.pb( - reservation.MoveAssignmentRequest() - ) + pb_message = iam_policy_pb2.TestIamPermissionsRequest() transcode.return_value = { "method": "post", "uri": "my_uri", @@ -18316,19 +23369,24 @@ def test_move_assignment_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 = reservation.Assignment.to_json(reservation.Assignment()) + return_value = json_format.MessageToJson( + iam_policy_pb2.TestIamPermissionsResponse() + ) req.return_value.content = return_value - request = reservation.MoveAssignmentRequest() + request = iam_policy_pb2.TestIamPermissionsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.Assignment() - post_with_metadata.return_value = reservation.Assignment(), metadata + post.return_value = iam_policy_pb2.TestIamPermissionsResponse() + post_with_metadata.return_value = ( + iam_policy_pb2.TestIamPermissionsResponse(), + metadata, + ) - client.move_assignment( + client.test_iam_permissions( request, metadata=[ ("key", "val"), @@ -18341,18 +23399,14 @@ def test_move_assignment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_assignment_rest_bad_request( - request_type=reservation.UpdateAssignmentRequest, +def test_create_reservation_group_rest_bad_request( + request_type=reservation.CreateReservationGroupRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "assignment": { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" - } - } + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -18367,40 +23421,32 @@ def test_update_assignment_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_assignment(request) + client.create_reservation_group(request) @pytest.mark.parametrize( "request_type", [ - reservation.UpdateAssignmentRequest, + reservation.CreateReservationGroupRequest, dict, ], ) -def test_update_assignment_rest_call_success(request_type): +def test_create_reservation_group_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "assignment": { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4" - } - } - request_init["assignment"] = { - "name": "projects/sample1/locations/sample2/reservations/sample3/assignments/sample4", - "assignee": "assignee_value", - "job_type": 1, - "state": 1, - "enable_gemini_in_bigquery": True, - } + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["reservation_group"] = {"name": "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 = reservation.UpdateAssignmentRequest.meta.fields["assignment"] + test_field = reservation.CreateReservationGroupRequest.meta.fields[ + "reservation_group" + ] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -18428,7 +23474,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["assignment"].items(): # pragma: NO COVER + for field, value in request_init["reservation_group"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -18458,21 +23504,17 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["assignment"][field])): - del request_init["assignment"][field][i][subfield] + for i in range(0, len(request_init["reservation_group"][field])): + del request_init["reservation_group"][field][i][subfield] else: - del request_init["assignment"][field][subfield] + del request_init["reservation_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 = reservation.Assignment( + return_value = reservation.ReservationGroup( name="name_value", - assignee="assignee_value", - job_type=reservation.Assignment.JobType.PIPELINE, - state=reservation.Assignment.State.PENDING, - enable_gemini_in_bigquery=True, ) # Wrap the value into a proper Response obj @@ -18480,24 +23522,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.Assignment.pb(return_value) + return_value = reservation.ReservationGroup.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_assignment(request) + response = client.create_reservation_group(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.Assignment) + assert isinstance(response, reservation.ReservationGroup) assert response.name == "name_value" - assert response.assignee == "assignee_value" - assert response.job_type == reservation.Assignment.JobType.PIPELINE - assert response.state == reservation.Assignment.State.PENDING - assert response.enable_gemini_in_bigquery is True @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_assignment_rest_interceptors(null_interceptor): +def test_create_reservation_group_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18511,18 +23549,18 @@ def test_update_assignment_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_update_assignment" + transports.ReservationServiceRestInterceptor, "post_create_reservation_group" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_update_assignment_with_metadata", + "post_create_reservation_group_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_update_assignment" + transports.ReservationServiceRestInterceptor, "pre_create_reservation_group" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.UpdateAssignmentRequest.pb( - reservation.UpdateAssignmentRequest() + pb_message = reservation.CreateReservationGroupRequest.pb( + reservation.CreateReservationGroupRequest() ) transcode.return_value = { "method": "post", @@ -18534,19 +23572,21 @@ def test_update_assignment_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 = reservation.Assignment.to_json(reservation.Assignment()) + return_value = reservation.ReservationGroup.to_json( + reservation.ReservationGroup() + ) req.return_value.content = return_value - request = reservation.UpdateAssignmentRequest() + request = reservation.CreateReservationGroupRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.Assignment() - post_with_metadata.return_value = reservation.Assignment(), metadata + post.return_value = reservation.ReservationGroup() + post_with_metadata.return_value = reservation.ReservationGroup(), metadata - client.update_assignment( + client.create_reservation_group( request, metadata=[ ("key", "val"), @@ -18559,14 +23599,16 @@ def test_update_assignment_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_bi_reservation_rest_bad_request( - request_type=reservation.GetBiReservationRequest, +def test_get_reservation_group_rest_bad_request( + request_type=reservation.GetReservationGroupRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/biReservation"} + request_init = { + "name": "projects/sample1/locations/sample2/reservationGroups/sample3" + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -18581,31 +23623,32 @@ def test_get_bi_reservation_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_bi_reservation(request) + client.get_reservation_group(request) @pytest.mark.parametrize( "request_type", [ - reservation.GetBiReservationRequest, + reservation.GetReservationGroupRequest, dict, ], ) -def test_get_bi_reservation_rest_call_success(request_type): +def test_get_reservation_group_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/biReservation"} + request_init = { + "name": "projects/sample1/locations/sample2/reservationGroups/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 = reservation.BiReservation( + return_value = reservation.ReservationGroup( name="name_value", - size=443, ) # Wrap the value into a proper Response obj @@ -18613,21 +23656,20 @@ def test_get_bi_reservation_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.BiReservation.pb(return_value) + return_value = reservation.ReservationGroup.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_bi_reservation(request) + response = client.get_reservation_group(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.BiReservation) + assert isinstance(response, reservation.ReservationGroup) assert response.name == "name_value" - assert response.size == 443 @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_bi_reservation_rest_interceptors(null_interceptor): +def test_get_reservation_group_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18641,18 +23683,18 @@ def test_get_bi_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_get_bi_reservation" + transports.ReservationServiceRestInterceptor, "post_get_reservation_group" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_get_bi_reservation_with_metadata", + "post_get_reservation_group_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_get_bi_reservation" + transports.ReservationServiceRestInterceptor, "pre_get_reservation_group" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.GetBiReservationRequest.pb( - reservation.GetBiReservationRequest() + pb_message = reservation.GetReservationGroupRequest.pb( + reservation.GetReservationGroupRequest() ) transcode.return_value = { "method": "post", @@ -18664,19 +23706,21 @@ def test_get_bi_reservation_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 = reservation.BiReservation.to_json(reservation.BiReservation()) + return_value = reservation.ReservationGroup.to_json( + reservation.ReservationGroup() + ) req.return_value.content = return_value - request = reservation.GetBiReservationRequest() + request = reservation.GetReservationGroupRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.BiReservation() - post_with_metadata.return_value = reservation.BiReservation(), metadata + post.return_value = reservation.ReservationGroup() + post_with_metadata.return_value = reservation.ReservationGroup(), metadata - client.get_bi_reservation( + client.get_reservation_group( request, metadata=[ ("key", "val"), @@ -18689,15 +23733,15 @@ def test_get_bi_reservation_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_bi_reservation_rest_bad_request( - request_type=reservation.UpdateBiReservationRequest, +def test_delete_reservation_group_rest_bad_request( + request_type=reservation.DeleteReservationGroupRequest, ): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "bi_reservation": {"name": "projects/sample1/locations/sample2/biReservation"} + "name": "projects/sample1/locations/sample2/reservationGroups/sample3" } request = request_type(**request_init) @@ -18713,112 +23757,141 @@ def test_update_bi_reservation_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_bi_reservation(request) + client.delete_reservation_group(request) @pytest.mark.parametrize( "request_type", [ - reservation.UpdateBiReservationRequest, + reservation.DeleteReservationGroupRequest, dict, ], ) -def test_update_bi_reservation_rest_call_success(request_type): +def test_delete_reservation_group_rest_call_success(request_type): client = ReservationServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "bi_reservation": {"name": "projects/sample1/locations/sample2/biReservation"} - } - request_init["bi_reservation"] = { - "name": "projects/sample1/locations/sample2/biReservation", - "update_time": {"seconds": 751, "nanos": 543}, - "size": 443, - "preferred_tables": [ - { - "project_id": "project_id_value", - "dataset_id": "dataset_id_value", - "table_id": "table_id_value", - } - ], + "name": "projects/sample1/locations/sample2/reservationGroups/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 + request = request_type(**request_init) - # Determine if the message type is proto-plus or protobuf - test_field = reservation.UpdateBiReservationRequest.meta.fields["bi_reservation"] + # Mock the http request call within the method and 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 - 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 = [] + # 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_reservation_group(request) - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_reservation_group_rest_interceptors(null_interceptor): + transport = transports.ReservationServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.ReservationServiceRestInterceptor(), + ) + client = ReservationServiceClient(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.ReservationServiceRestInterceptor, "pre_delete_reservation_group" + ) as pre: + pre.assert_not_called() + pb_message = reservation.DeleteReservationGroupRequest.pb( + reservation.DeleteReservationGroupRequest() + ) + 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 = reservation.DeleteReservationGroupRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + + client.delete_reservation_group( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] +def test_list_reservation_groups_rest_bad_request( + request_type=reservation.ListReservationGroupsRequest, +): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) - 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.list_reservation_groups(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["bi_reservation"].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", + [ + reservation.ListReservationGroupsRequest, + dict, + ], +) +def test_list_reservation_groups_rest_call_success(request_type): + client = ReservationServiceClient( + 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["bi_reservation"][field])): - del request_init["bi_reservation"][field][i][subfield] - else: - del request_init["bi_reservation"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = reservation.BiReservation( - name="name_value", - size=443, + return_value = reservation.ListReservationGroupsResponse( + next_page_token="next_page_token_value", ) # Wrap the value into a proper Response obj @@ -18826,21 +23899,20 @@ def get_message_fields(field): response_value.status_code = 200 # Convert return value to protobuf type - return_value = reservation.BiReservation.pb(return_value) + return_value = reservation.ListReservationGroupsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_bi_reservation(request) + response = client.list_reservation_groups(request) # Establish that the response is the type that we expect. - assert isinstance(response, reservation.BiReservation) - assert response.name == "name_value" - assert response.size == 443 + assert isinstance(response, pagers.ListReservationGroupsPager) + assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_bi_reservation_rest_interceptors(null_interceptor): +def test_list_reservation_groups_rest_interceptors(null_interceptor): transport = transports.ReservationServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -18854,18 +23926,18 @@ def test_update_bi_reservation_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.ReservationServiceRestInterceptor, "post_update_bi_reservation" + transports.ReservationServiceRestInterceptor, "post_list_reservation_groups" ) as post, mock.patch.object( transports.ReservationServiceRestInterceptor, - "post_update_bi_reservation_with_metadata", + "post_list_reservation_groups_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.ReservationServiceRestInterceptor, "pre_update_bi_reservation" + transports.ReservationServiceRestInterceptor, "pre_list_reservation_groups" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = reservation.UpdateBiReservationRequest.pb( - reservation.UpdateBiReservationRequest() + pb_message = reservation.ListReservationGroupsRequest.pb( + reservation.ListReservationGroupsRequest() ) transcode.return_value = { "method": "post", @@ -18877,19 +23949,24 @@ def test_update_bi_reservation_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 = reservation.BiReservation.to_json(reservation.BiReservation()) + return_value = reservation.ListReservationGroupsResponse.to_json( + reservation.ListReservationGroupsResponse() + ) req.return_value.content = return_value - request = reservation.UpdateBiReservationRequest() + request = reservation.ListReservationGroupsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = reservation.BiReservation() - post_with_metadata.return_value = reservation.BiReservation(), metadata + post.return_value = reservation.ListReservationGroupsResponse() + post_with_metadata.return_value = ( + reservation.ListReservationGroupsResponse(), + metadata, + ) - client.update_bi_reservation( + client.list_reservation_groups( request, metadata=[ ("key", "val"), @@ -19387,6 +24464,156 @@ def test_update_bi_reservation_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_get_iam_policy_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_iam_policy), "__call__") as call: + client.get_iam_policy(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.GetIamPolicyRequest() + + assert args[0] == request_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_set_iam_policy_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.set_iam_policy), "__call__") as call: + client.set_iam_policy(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.SetIamPolicyRequest() + + assert args[0] == request_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_test_iam_permissions_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.test_iam_permissions), "__call__" + ) as call: + client.test_iam_permissions(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = iam_policy_pb2.TestIamPermissionsRequest() + + assert args[0] == request_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_reservation_group_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_reservation_group), "__call__" + ) as call: + client.create_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.CreateReservationGroupRequest() + + assert args[0] == request_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_reservation_group_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_reservation_group), "__call__" + ) as call: + client.get_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.GetReservationGroupRequest() + + assert args[0] == request_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_reservation_group_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_reservation_group), "__call__" + ) as call: + client.delete_reservation_group(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.DeleteReservationGroupRequest() + + assert args[0] == request_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_reservation_groups_empty_call_rest(): + client = ReservationServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_reservation_groups), "__call__" + ) as call: + client.list_reservation_groups(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = reservation.ListReservationGroupsRequest() + + assert args[0] == request_msg + + def test_transport_grpc_default(): # A client should use the gRPC transport by default. client = ReservationServiceClient( @@ -19442,6 +24669,13 @@ def test_reservation_service_base_transport(): "update_assignment", "get_bi_reservation", "update_bi_reservation", + "get_iam_policy", + "set_iam_policy", + "test_iam_permissions", + "create_reservation_group", + "get_reservation_group", + "delete_reservation_group", + "list_reservation_groups", ) for method in methods: with pytest.raises(NotImplementedError): @@ -19780,6 +25014,27 @@ def test_reservation_service_client_transport_session_collision(transport_name): session1 = client1.transport.update_bi_reservation._session session2 = client2.transport.update_bi_reservation._session assert session1 != session2 + session1 = client1.transport.get_iam_policy._session + session2 = client2.transport.get_iam_policy._session + assert session1 != session2 + session1 = client1.transport.set_iam_policy._session + session2 = client2.transport.set_iam_policy._session + assert session1 != session2 + session1 = client1.transport.test_iam_permissions._session + session2 = client2.transport.test_iam_permissions._session + assert session1 != session2 + session1 = client1.transport.create_reservation_group._session + session2 = client2.transport.create_reservation_group._session + assert session1 != session2 + session1 = client1.transport.get_reservation_group._session + session2 = client2.transport.get_reservation_group._session + assert session1 != session2 + session1 = client1.transport.delete_reservation_group._session + session2 = client2.transport.delete_reservation_group._session + assert session1 != session2 + session1 = client1.transport.list_reservation_groups._session + session2 = client2.transport.list_reservation_groups._session + assert session1 != session2 def test_reservation_service_grpc_transport_channel(): @@ -20018,8 +25273,36 @@ def test_parse_reservation_path(): assert expected == actual +def test_reservation_group_path(): + project = "squid" + location = "clam" + reservation_group = "whelk" + expected = "projects/{project}/locations/{location}/reservationGroups/{reservation_group}".format( + project=project, + location=location, + reservation_group=reservation_group, + ) + actual = ReservationServiceClient.reservation_group_path( + project, location, reservation_group + ) + assert expected == actual + + +def test_parse_reservation_group_path(): + expected = { + "project": "octopus", + "location": "oyster", + "reservation_group": "nudibranch", + } + path = ReservationServiceClient.reservation_group_path(**expected) + + # Check that the path construction is reversible. + actual = ReservationServiceClient.parse_reservation_group_path(path) + assert expected == actual + + def test_common_billing_account_path(): - billing_account = "squid" + billing_account = "cuttlefish" expected = "billingAccounts/{billing_account}".format( billing_account=billing_account, ) @@ -20029,7 +25312,7 @@ def test_common_billing_account_path(): def test_parse_common_billing_account_path(): expected = { - "billing_account": "clam", + "billing_account": "mussel", } path = ReservationServiceClient.common_billing_account_path(**expected) @@ -20039,7 +25322,7 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): - folder = "whelk" + folder = "winkle" expected = "folders/{folder}".format( folder=folder, ) @@ -20049,7 +25332,7 @@ def test_common_folder_path(): def test_parse_common_folder_path(): expected = { - "folder": "octopus", + "folder": "nautilus", } path = ReservationServiceClient.common_folder_path(**expected) @@ -20059,7 +25342,7 @@ def test_parse_common_folder_path(): def test_common_organization_path(): - organization = "oyster" + organization = "scallop" expected = "organizations/{organization}".format( organization=organization, ) @@ -20069,7 +25352,7 @@ def test_common_organization_path(): def test_parse_common_organization_path(): expected = { - "organization": "nudibranch", + "organization": "abalone", } path = ReservationServiceClient.common_organization_path(**expected) @@ -20079,7 +25362,7 @@ def test_parse_common_organization_path(): def test_common_project_path(): - project = "cuttlefish" + project = "squid" expected = "projects/{project}".format( project=project, ) @@ -20089,7 +25372,7 @@ def test_common_project_path(): def test_parse_common_project_path(): expected = { - "project": "mussel", + "project": "clam", } path = ReservationServiceClient.common_project_path(**expected) @@ -20099,8 +25382,8 @@ def test_parse_common_project_path(): def test_common_location_path(): - project = "winkle" - location = "nautilus" + project = "whelk" + location = "octopus" expected = "projects/{project}/locations/{location}".format( project=project, location=location, @@ -20111,8 +25394,8 @@ def test_common_location_path(): def test_parse_common_location_path(): expected = { - "project": "scallop", - "location": "abalone", + "project": "oyster", + "location": "nudibranch", } path = ReservationServiceClient.common_location_path(**expected)