From bb482e99bd496489fb589a8fc154692585cef061 Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Tue, 6 May 2025 13:04:14 -0700 Subject: [PATCH 1/8] chore: Update gapic-generator-python to 1.24.1 (#1035) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: add the UserCreds API PiperOrigin-RevId: 742708704 Source-Link: https://github.com/googleapis/googleapis/commit/35980b69879ecc9d0db6343311ef2fa03976ee99 Source-Link: https://github.com/googleapis/googleapis-gen/commit/23742c6deecc81de0525d2ee7980e258e43fee5b Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiMjM3NDJjNmRlZWNjODFkZTA1MjVkMmVlNzk4MGUyNThlNDNmZWU1YiJ9 * πŸ¦‰ Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md * feat: new Firestore index modes and Database Editions PiperOrigin-RevId: 745570206 Source-Link: https://github.com/googleapis/googleapis/commit/4ec607bd375cddbec6d28bc1931eab7da221e4bb Source-Link: https://github.com/googleapis/googleapis-gen/commit/49fab778b7098870f991ebde91da5f926f406fd5 Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiNDlmYWI3NzhiNzA5ODg3MGY5OTFlYmRlOTFkYTVmOTI2ZjQwNmZkNSJ9 * πŸ¦‰ Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md * chore: Update gapic-generator-python to 1.24.0 PiperOrigin-RevId: 747419463 Source-Link: https://github.com/googleapis/googleapis/commit/340579bf7f97ba56cda0c70176dc5b03a8357667 Source-Link: https://github.com/googleapis/googleapis-gen/commit/e8997ec5136ecb6ed9a969a4c2f13b3ab6a17c12 Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiZTg5OTdlYzUxMzZlY2I2ZWQ5YTk2OWE0YzJmMTNiM2FiNmExN2MxMiJ9 * πŸ¦‰ Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md * chore: Update gapic-generator-python to 1.24.1 PiperOrigin-RevId: 748739072 Source-Link: https://github.com/googleapis/googleapis/commit/b947e523934dbac5d97613d8aa08e04fc38c5fb6 Source-Link: https://github.com/googleapis/googleapis-gen/commit/8c5821aa65a921d59b3f7653d6f37c9c67410c2f Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiOGM1ODIxYWE2NWE5MjFkNTliM2Y3NjUzZDZmMzdjOWM2NzQxMGMyZiJ9 * πŸ¦‰ Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md --------- Co-authored-by: Owl Bot Co-authored-by: Daniel Sanche --- .../firestore_admin_v1/gapic_metadata.json | 105 + .../services/firestore_admin/async_client.py | 789 + .../services/firestore_admin/client.py | 788 + .../firestore_admin/transports/base.py | 103 + .../firestore_admin/transports/grpc.py | 194 +- .../transports/grpc_asyncio.py | 237 + .../firestore_admin/transports/rest.py | 2270 ++- .../firestore_admin/transports/rest_base.py | 373 + .../firestore_admin_v1/types/__init__.py | 20 + .../firestore_admin_v1/types/database.py | 49 + .../types/firestore_admin.py | 157 + .../cloud/firestore_admin_v1/types/index.py | 63 + .../firestore_admin_v1/types/user_creds.py | 124 + .../services/firestore/transports/grpc.py | 3 +- scripts/fixup_firestore_admin_v1_keywords.py | 7 + .../test_firestore_admin.py | 13425 +++++++++++----- 16 files changed, 14204 insertions(+), 4503 deletions(-) create mode 100644 google/cloud/firestore_admin_v1/types/user_creds.py diff --git a/google/cloud/firestore_admin_v1/gapic_metadata.json b/google/cloud/firestore_admin_v1/gapic_metadata.json index f036e7a6c1..e2c91bdb59 100644 --- a/google/cloud/firestore_admin_v1/gapic_metadata.json +++ b/google/cloud/firestore_admin_v1/gapic_metadata.json @@ -30,6 +30,11 @@ "create_index" ] }, + "CreateUserCreds": { + "methods": [ + "create_user_creds" + ] + }, "DeleteBackup": { "methods": [ "delete_backup" @@ -50,6 +55,21 @@ "delete_index" ] }, + "DeleteUserCreds": { + "methods": [ + "delete_user_creds" + ] + }, + "DisableUserCreds": { + "methods": [ + "disable_user_creds" + ] + }, + "EnableUserCreds": { + "methods": [ + "enable_user_creds" + ] + }, "ExportDocuments": { "methods": [ "export_documents" @@ -80,6 +100,11 @@ "get_index" ] }, + "GetUserCreds": { + "methods": [ + "get_user_creds" + ] + }, "ImportDocuments": { "methods": [ "import_documents" @@ -110,6 +135,16 @@ "list_indexes" ] }, + "ListUserCreds": { + "methods": [ + "list_user_creds" + ] + }, + "ResetUserPassword": { + "methods": [ + "reset_user_password" + ] + }, "RestoreDatabase": { "methods": [ "restore_database" @@ -155,6 +190,11 @@ "create_index" ] }, + "CreateUserCreds": { + "methods": [ + "create_user_creds" + ] + }, "DeleteBackup": { "methods": [ "delete_backup" @@ -175,6 +215,21 @@ "delete_index" ] }, + "DeleteUserCreds": { + "methods": [ + "delete_user_creds" + ] + }, + "DisableUserCreds": { + "methods": [ + "disable_user_creds" + ] + }, + "EnableUserCreds": { + "methods": [ + "enable_user_creds" + ] + }, "ExportDocuments": { "methods": [ "export_documents" @@ -205,6 +260,11 @@ "get_index" ] }, + "GetUserCreds": { + "methods": [ + "get_user_creds" + ] + }, "ImportDocuments": { "methods": [ "import_documents" @@ -235,6 +295,16 @@ "list_indexes" ] }, + "ListUserCreds": { + "methods": [ + "list_user_creds" + ] + }, + "ResetUserPassword": { + "methods": [ + "reset_user_password" + ] + }, "RestoreDatabase": { "methods": [ "restore_database" @@ -280,6 +350,11 @@ "create_index" ] }, + "CreateUserCreds": { + "methods": [ + "create_user_creds" + ] + }, "DeleteBackup": { "methods": [ "delete_backup" @@ -300,6 +375,21 @@ "delete_index" ] }, + "DeleteUserCreds": { + "methods": [ + "delete_user_creds" + ] + }, + "DisableUserCreds": { + "methods": [ + "disable_user_creds" + ] + }, + "EnableUserCreds": { + "methods": [ + "enable_user_creds" + ] + }, "ExportDocuments": { "methods": [ "export_documents" @@ -330,6 +420,11 @@ "get_index" ] }, + "GetUserCreds": { + "methods": [ + "get_user_creds" + ] + }, "ImportDocuments": { "methods": [ "import_documents" @@ -360,6 +455,16 @@ "list_indexes" ] }, + "ListUserCreds": { + "methods": [ + "list_user_creds" + ] + }, + "ResetUserPassword": { + "methods": [ + "reset_user_password" + ] + }, "RestoreDatabase": { "methods": [ "restore_database" diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py b/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py index bd903a17d4..b7b4f67e7e 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py @@ -57,6 +57,8 @@ from google.cloud.firestore_admin_v1.types import index as gfa_index from google.cloud.firestore_admin_v1.types import operation as gfa_operation from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.cloud.location import locations_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore from google.protobuf import duration_pb2 # type: ignore @@ -140,6 +142,8 @@ class FirestoreAdminAsyncClient: parse_location_path = staticmethod(FirestoreAdminClient.parse_location_path) operation_path = staticmethod(FirestoreAdminClient.operation_path) parse_operation_path = staticmethod(FirestoreAdminClient.parse_operation_path) + user_creds_path = staticmethod(FirestoreAdminClient.user_creds_path) + parse_user_creds_path = staticmethod(FirestoreAdminClient.parse_user_creds_path) common_billing_account_path = staticmethod( FirestoreAdminClient.common_billing_account_path ) @@ -2277,6 +2281,791 @@ async def sample_delete_database(): # Done; return the response. return response + async def create_user_creds( + self, + request: Optional[Union[firestore_admin.CreateUserCredsRequest, dict]] = None, + *, + parent: Optional[str] = None, + user_creds: Optional[gfa_user_creds.UserCreds] = None, + user_creds_id: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> gfa_user_creds.UserCreds: + r"""Create a user creds. + + .. 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 firestore_admin_v1 + + async def sample_create_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.CreateUserCredsRequest( + parent="parent_value", + user_creds_id="user_creds_id_value", + ) + + # Make the request + response = await client.create_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.CreateUserCredsRequest, dict]]): + The request object. The request for + [FirestoreAdmin.CreateUserCreds][google.firestore.admin.v1.FirestoreAdmin.CreateUserCreds]. + parent (:class:`str`): + Required. A parent name of the form + ``projects/{project_id}/databases/{database_id}`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + user_creds (:class:`google.cloud.firestore_admin_v1.types.UserCreds`): + Required. The user creds to create. + This corresponds to the ``user_creds`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + user_creds_id (:class:`str`): + Required. The ID to use for the user creds, which will + become the final component of the user creds's resource + name. + + This value should be 4-63 characters. Valid characters + are /[a-z][0-9]-/ with first character a letter and the + last a letter or a number. Must not be UUID-like + /[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}/. + + This corresponds to the ``user_creds_id`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, user_creds, user_creds_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, firestore_admin.CreateUserCredsRequest): + request = firestore_admin.CreateUserCredsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if user_creds is not None: + request.user_creds = user_creds + if user_creds_id is not None: + request.user_creds_id = user_creds_id + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.create_user_creds + ] + + # 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_user_creds( + self, + request: Optional[Union[firestore_admin.GetUserCredsRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Gets a user creds resource. Note that the returned + resource does not contain the secret value itself. + + .. 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 firestore_admin_v1 + + async def sample_get_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.GetUserCredsRequest( + name="name_value", + ) + + # Make the request + response = await client.get_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.GetUserCredsRequest, dict]]): + The request object. The request for + [FirestoreAdmin.GetUserCreds][google.firestore.admin.v1.FirestoreAdmin.GetUserCreds]. + name (:class:`str`): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.GetUserCredsRequest): + request = firestore_admin.GetUserCredsRequest(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_user_creds + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def list_user_creds( + self, + request: Optional[Union[firestore_admin.ListUserCredsRequest, 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]]] = (), + ) -> firestore_admin.ListUserCredsResponse: + r"""List all user creds in the database. Note that the + returned resource does not contain the secret value + itself. + + .. 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 firestore_admin_v1 + + async def sample_list_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.ListUserCredsRequest( + parent="parent_value", + ) + + # Make the request + response = await client.list_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.ListUserCredsRequest, dict]]): + The request object. The request for + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. + parent (:class:`str`): + Required. A parent database name of the form + ``projects/{project_id}/databases/{database_id}`` + + 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.firestore_admin_v1.types.ListUserCredsResponse: + The response for + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. + + """ + # 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, firestore_admin.ListUserCredsRequest): + request = firestore_admin.ListUserCredsRequest(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_user_creds + ] + + # 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 enable_user_creds( + self, + request: Optional[Union[firestore_admin.EnableUserCredsRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Enables a user creds. No-op if the user creds are + already enabled. + + .. 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 firestore_admin_v1 + + async def sample_enable_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.EnableUserCredsRequest( + name="name_value", + ) + + # Make the request + response = await client.enable_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.EnableUserCredsRequest, dict]]): + The request object. The request for + [FirestoreAdmin.EnableUserCreds][google.firestore.admin.v1.FirestoreAdmin.EnableUserCreds]. + name (:class:`str`): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.EnableUserCredsRequest): + request = firestore_admin.EnableUserCredsRequest(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.enable_user_creds + ] + + # 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 disable_user_creds( + self, + request: Optional[Union[firestore_admin.DisableUserCredsRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Disables a user creds. No-op if the user creds are + already disabled. + + .. 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 firestore_admin_v1 + + async def sample_disable_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.DisableUserCredsRequest( + name="name_value", + ) + + # Make the request + response = await client.disable_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.DisableUserCredsRequest, dict]]): + The request object. The request for + [FirestoreAdmin.DisableUserCreds][google.firestore.admin.v1.FirestoreAdmin.DisableUserCreds]. + name (:class:`str`): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.DisableUserCredsRequest): + request = firestore_admin.DisableUserCredsRequest(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.disable_user_creds + ] + + # 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 reset_user_password( + self, + request: Optional[Union[firestore_admin.ResetUserPasswordRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Resets the password of a user creds. + + .. 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 firestore_admin_v1 + + async def sample_reset_user_password(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.ResetUserPasswordRequest( + name="name_value", + ) + + # Make the request + response = await client.reset_user_password(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.ResetUserPasswordRequest, dict]]): + The request object. The request for + [FirestoreAdmin.ResetUserPassword][google.firestore.admin.v1.FirestoreAdmin.ResetUserPassword]. + name (:class:`str`): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.ResetUserPasswordRequest): + request = firestore_admin.ResetUserPasswordRequest(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.reset_user_password + ] + + # 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_user_creds( + self, + request: Optional[Union[firestore_admin.DeleteUserCredsRequest, 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 user creds. + + .. 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 firestore_admin_v1 + + async def sample_delete_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminAsyncClient() + + # Initialize request argument(s) + request = firestore_admin_v1.DeleteUserCredsRequest( + name="name_value", + ) + + # Make the request + await client.delete_user_creds(request=request) + + Args: + request (Optional[Union[google.cloud.firestore_admin_v1.types.DeleteUserCredsRequest, dict]]): + The request object. The request for + [FirestoreAdmin.DeleteUserCreds][google.firestore.admin.v1.FirestoreAdmin.DeleteUserCreds]. + name (:class:`str`): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + # 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, firestore_admin.DeleteUserCredsRequest): + request = firestore_admin.DeleteUserCredsRequest(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_user_creds + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + async def get_backup( self, request: Optional[Union[firestore_admin.GetBackupRequest, dict]] = None, diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/client.py b/google/cloud/firestore_admin_v1/services/firestore_admin/client.py index 9c80fabfc7..3774fa7f22 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/client.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/client.py @@ -73,6 +73,8 @@ from google.cloud.firestore_admin_v1.types import index as gfa_index from google.cloud.firestore_admin_v1.types import operation as gfa_operation from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.cloud.location import locations_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore from google.protobuf import duration_pb2 # type: ignore @@ -412,6 +414,28 @@ def parse_operation_path(path: str) -> Dict[str, str]: ) return m.groupdict() if m else {} + @staticmethod + def user_creds_path( + project: str, + database: str, + user_creds: str, + ) -> str: + """Returns a fully-qualified user_creds string.""" + return "projects/{project}/databases/{database}/userCreds/{user_creds}".format( + project=project, + database=database, + user_creds=user_creds, + ) + + @staticmethod + def parse_user_creds_path(path: str) -> Dict[str, str]: + """Parses a user_creds path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/databases/(?P.+?)/userCreds/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + @staticmethod def common_billing_account_path( billing_account: str, @@ -2784,6 +2808,770 @@ def sample_delete_database(): # Done; return the response. return response + def create_user_creds( + self, + request: Optional[Union[firestore_admin.CreateUserCredsRequest, dict]] = None, + *, + parent: Optional[str] = None, + user_creds: Optional[gfa_user_creds.UserCreds] = None, + user_creds_id: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> gfa_user_creds.UserCreds: + r"""Create a user creds. + + .. 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 firestore_admin_v1 + + def sample_create_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.CreateUserCredsRequest( + parent="parent_value", + user_creds_id="user_creds_id_value", + ) + + # Make the request + response = client.create_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.CreateUserCredsRequest, dict]): + The request object. The request for + [FirestoreAdmin.CreateUserCreds][google.firestore.admin.v1.FirestoreAdmin.CreateUserCreds]. + parent (str): + Required. A parent name of the form + ``projects/{project_id}/databases/{database_id}`` + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + user_creds (google.cloud.firestore_admin_v1.types.UserCreds): + Required. The user creds to create. + This corresponds to the ``user_creds`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + user_creds_id (str): + Required. The ID to use for the user creds, which will + become the final component of the user creds's resource + name. + + This value should be 4-63 characters. Valid characters + are /[a-z][0-9]-/ with first character a letter and the + last a letter or a number. Must not be UUID-like + /[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}/. + + This corresponds to the ``user_creds_id`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, user_creds, user_creds_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, firestore_admin.CreateUserCredsRequest): + request = firestore_admin.CreateUserCredsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if user_creds is not None: + request.user_creds = user_creds + if user_creds_id is not None: + request.user_creds_id = user_creds_id + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.create_user_creds] + + # 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_user_creds( + self, + request: Optional[Union[firestore_admin.GetUserCredsRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Gets a user creds resource. Note that the returned + resource does not contain the secret value itself. + + .. 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 firestore_admin_v1 + + def sample_get_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.GetUserCredsRequest( + name="name_value", + ) + + # Make the request + response = client.get_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.GetUserCredsRequest, dict]): + The request object. The request for + [FirestoreAdmin.GetUserCreds][google.firestore.admin.v1.FirestoreAdmin.GetUserCreds]. + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.GetUserCredsRequest): + request = firestore_admin.GetUserCredsRequest(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_user_creds] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def list_user_creds( + self, + request: Optional[Union[firestore_admin.ListUserCredsRequest, 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]]] = (), + ) -> firestore_admin.ListUserCredsResponse: + r"""List all user creds in the database. Note that the + returned resource does not contain the secret value + itself. + + .. 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 firestore_admin_v1 + + def sample_list_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.ListUserCredsRequest( + parent="parent_value", + ) + + # Make the request + response = client.list_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.ListUserCredsRequest, dict]): + The request object. The request for + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. + parent (str): + Required. A parent database name of the form + ``projects/{project_id}/databases/{database_id}`` + + 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.firestore_admin_v1.types.ListUserCredsResponse: + The response for + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. + + """ + # 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, firestore_admin.ListUserCredsRequest): + request = firestore_admin.ListUserCredsRequest(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_user_creds] + + # 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 enable_user_creds( + self, + request: Optional[Union[firestore_admin.EnableUserCredsRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Enables a user creds. No-op if the user creds are + already enabled. + + .. 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 firestore_admin_v1 + + def sample_enable_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.EnableUserCredsRequest( + name="name_value", + ) + + # Make the request + response = client.enable_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.EnableUserCredsRequest, dict]): + The request object. The request for + [FirestoreAdmin.EnableUserCreds][google.firestore.admin.v1.FirestoreAdmin.EnableUserCreds]. + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.EnableUserCredsRequest): + request = firestore_admin.EnableUserCredsRequest(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.enable_user_creds] + + # 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 disable_user_creds( + self, + request: Optional[Union[firestore_admin.DisableUserCredsRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Disables a user creds. No-op if the user creds are + already disabled. + + .. 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 firestore_admin_v1 + + def sample_disable_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.DisableUserCredsRequest( + name="name_value", + ) + + # Make the request + response = client.disable_user_creds(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.DisableUserCredsRequest, dict]): + The request object. The request for + [FirestoreAdmin.DisableUserCreds][google.firestore.admin.v1.FirestoreAdmin.DisableUserCreds]. + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.DisableUserCredsRequest): + request = firestore_admin.DisableUserCredsRequest(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.disable_user_creds] + + # 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 reset_user_password( + self, + request: Optional[Union[firestore_admin.ResetUserPasswordRequest, 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]]] = (), + ) -> user_creds.UserCreds: + r"""Resets the password of a user creds. + + .. 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 firestore_admin_v1 + + def sample_reset_user_password(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.ResetUserPasswordRequest( + name="name_value", + ) + + # Make the request + response = client.reset_user_password(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.ResetUserPasswordRequest, dict]): + The request object. The request for + [FirestoreAdmin.ResetUserPassword][google.firestore.admin.v1.FirestoreAdmin.ResetUserPassword]. + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + google.cloud.firestore_admin_v1.types.UserCreds: + A Cloud Firestore User Creds. + """ + # 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, firestore_admin.ResetUserPasswordRequest): + request = firestore_admin.ResetUserPasswordRequest(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.reset_user_password] + + # 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_user_creds( + self, + request: Optional[Union[firestore_admin.DeleteUserCredsRequest, 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 user creds. + + .. 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 firestore_admin_v1 + + def sample_delete_user_creds(): + # Create a client + client = firestore_admin_v1.FirestoreAdminClient() + + # Initialize request argument(s) + request = firestore_admin_v1.DeleteUserCredsRequest( + name="name_value", + ) + + # Make the request + client.delete_user_creds(request=request) + + Args: + request (Union[google.cloud.firestore_admin_v1.types.DeleteUserCredsRequest, dict]): + The request object. The request for + [FirestoreAdmin.DeleteUserCreds][google.firestore.admin.v1.FirestoreAdmin.DeleteUserCreds]. + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + """ + # 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, firestore_admin.DeleteUserCredsRequest): + request = firestore_admin.DeleteUserCredsRequest(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_user_creds] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + def get_backup( self, request: Optional[Union[firestore_admin.GetBackupRequest, dict]] = None, diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py index a209ae1697..d866350130 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py @@ -33,6 +33,8 @@ from google.cloud.firestore_admin_v1.types import firestore_admin from google.cloud.firestore_admin_v1.types import index from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.cloud.location import locations_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore @@ -271,6 +273,41 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.create_user_creds: gapic_v1.method.wrap_method( + self.create_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.get_user_creds: gapic_v1.method.wrap_method( + self.get_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.list_user_creds: gapic_v1.method.wrap_method( + self.list_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.enable_user_creds: gapic_v1.method.wrap_method( + self.enable_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.disable_user_creds: gapic_v1.method.wrap_method( + self.disable_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.reset_user_password: gapic_v1.method.wrap_method( + self.reset_user_password, + default_timeout=None, + client_info=client_info, + ), + self.delete_user_creds: gapic_v1.method.wrap_method( + self.delete_user_creds, + default_timeout=None, + client_info=client_info, + ), self.get_backup: gapic_v1.method.wrap_method( self.get_backup, default_timeout=None, @@ -494,6 +531,72 @@ def delete_database( ]: raise NotImplementedError() + @property + def create_user_creds( + self, + ) -> Callable[ + [firestore_admin.CreateUserCredsRequest], + Union[gfa_user_creds.UserCreds, Awaitable[gfa_user_creds.UserCreds]], + ]: + raise NotImplementedError() + + @property + def get_user_creds( + self, + ) -> Callable[ + [firestore_admin.GetUserCredsRequest], + Union[user_creds.UserCreds, Awaitable[user_creds.UserCreds]], + ]: + raise NotImplementedError() + + @property + def list_user_creds( + self, + ) -> Callable[ + [firestore_admin.ListUserCredsRequest], + Union[ + firestore_admin.ListUserCredsResponse, + Awaitable[firestore_admin.ListUserCredsResponse], + ], + ]: + raise NotImplementedError() + + @property + def enable_user_creds( + self, + ) -> Callable[ + [firestore_admin.EnableUserCredsRequest], + Union[user_creds.UserCreds, Awaitable[user_creds.UserCreds]], + ]: + raise NotImplementedError() + + @property + def disable_user_creds( + self, + ) -> Callable[ + [firestore_admin.DisableUserCredsRequest], + Union[user_creds.UserCreds, Awaitable[user_creds.UserCreds]], + ]: + raise NotImplementedError() + + @property + def reset_user_password( + self, + ) -> Callable[ + [firestore_admin.ResetUserPasswordRequest], + Union[user_creds.UserCreds, Awaitable[user_creds.UserCreds]], + ]: + raise NotImplementedError() + + @property + def delete_user_creds( + self, + ) -> Callable[ + [firestore_admin.DeleteUserCredsRequest], + Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], + ]: + raise NotImplementedError() + @property def get_backup( self, diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc.py index 4327bd1ff2..c6e7824c23 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc.py @@ -37,6 +37,8 @@ from google.cloud.firestore_admin_v1.types import firestore_admin from google.cloud.firestore_admin_v1.types import index from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.cloud.location import locations_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore @@ -79,12 +81,11 @@ def intercept_unary_unary(self, continuation, client_call_details, request): f"Sending request for {client_call_details.method}", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": client_call_details.method, + "rpcName": str(client_call_details.method), "request": grpc_request, "metadata": grpc_request["metadata"], }, ) - response = continuation(client_call_details, request) if logging_enabled: # pragma: NO COVER response_metadata = response.trailing_metadata() @@ -827,6 +828,195 @@ def delete_database( ) return self._stubs["delete_database"] + @property + def create_user_creds( + self, + ) -> Callable[[firestore_admin.CreateUserCredsRequest], gfa_user_creds.UserCreds]: + r"""Return a callable for the create user creds method over gRPC. + + Create a user creds. + + Returns: + Callable[[~.CreateUserCredsRequest], + ~.UserCreds]: + 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_user_creds" not in self._stubs: + self._stubs["create_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/CreateUserCreds", + request_serializer=firestore_admin.CreateUserCredsRequest.serialize, + response_deserializer=gfa_user_creds.UserCreds.deserialize, + ) + return self._stubs["create_user_creds"] + + @property + def get_user_creds( + self, + ) -> Callable[[firestore_admin.GetUserCredsRequest], user_creds.UserCreds]: + r"""Return a callable for the get user creds method over gRPC. + + Gets a user creds resource. Note that the returned + resource does not contain the secret value itself. + + Returns: + Callable[[~.GetUserCredsRequest], + ~.UserCreds]: + 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_user_creds" not in self._stubs: + self._stubs["get_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/GetUserCreds", + request_serializer=firestore_admin.GetUserCredsRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["get_user_creds"] + + @property + def list_user_creds( + self, + ) -> Callable[ + [firestore_admin.ListUserCredsRequest], firestore_admin.ListUserCredsResponse + ]: + r"""Return a callable for the list user creds method over gRPC. + + List all user creds in the database. Note that the + returned resource does not contain the secret value + itself. + + Returns: + Callable[[~.ListUserCredsRequest], + ~.ListUserCredsResponse]: + 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_user_creds" not in self._stubs: + self._stubs["list_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/ListUserCreds", + request_serializer=firestore_admin.ListUserCredsRequest.serialize, + response_deserializer=firestore_admin.ListUserCredsResponse.deserialize, + ) + return self._stubs["list_user_creds"] + + @property + def enable_user_creds( + self, + ) -> Callable[[firestore_admin.EnableUserCredsRequest], user_creds.UserCreds]: + r"""Return a callable for the enable user creds method over gRPC. + + Enables a user creds. No-op if the user creds are + already enabled. + + Returns: + Callable[[~.EnableUserCredsRequest], + ~.UserCreds]: + 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 "enable_user_creds" not in self._stubs: + self._stubs["enable_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/EnableUserCreds", + request_serializer=firestore_admin.EnableUserCredsRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["enable_user_creds"] + + @property + def disable_user_creds( + self, + ) -> Callable[[firestore_admin.DisableUserCredsRequest], user_creds.UserCreds]: + r"""Return a callable for the disable user creds method over gRPC. + + Disables a user creds. No-op if the user creds are + already disabled. + + Returns: + Callable[[~.DisableUserCredsRequest], + ~.UserCreds]: + 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 "disable_user_creds" not in self._stubs: + self._stubs["disable_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/DisableUserCreds", + request_serializer=firestore_admin.DisableUserCredsRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["disable_user_creds"] + + @property + def reset_user_password( + self, + ) -> Callable[[firestore_admin.ResetUserPasswordRequest], user_creds.UserCreds]: + r"""Return a callable for the reset user password method over gRPC. + + Resets the password of a user creds. + + Returns: + Callable[[~.ResetUserPasswordRequest], + ~.UserCreds]: + 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 "reset_user_password" not in self._stubs: + self._stubs["reset_user_password"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/ResetUserPassword", + request_serializer=firestore_admin.ResetUserPasswordRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["reset_user_password"] + + @property + def delete_user_creds( + self, + ) -> Callable[[firestore_admin.DeleteUserCredsRequest], empty_pb2.Empty]: + r"""Return a callable for the delete user creds method over gRPC. + + Deletes a user creds. + + Returns: + Callable[[~.DeleteUserCredsRequest], + ~.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_user_creds" not in self._stubs: + self._stubs["delete_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/DeleteUserCreds", + request_serializer=firestore_admin.DeleteUserCredsRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_user_creds"] + @property def get_backup(self) -> Callable[[firestore_admin.GetBackupRequest], backup.Backup]: r"""Return a callable for the get backup method over gRPC. diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc_asyncio.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc_asyncio.py index a06b00befb..9dd9d61556 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc_asyncio.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/grpc_asyncio.py @@ -40,6 +40,8 @@ from google.cloud.firestore_admin_v1.types import firestore_admin from google.cloud.firestore_admin_v1.types import index from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.cloud.location import locations_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore @@ -856,6 +858,206 @@ def delete_database( ) return self._stubs["delete_database"] + @property + def create_user_creds( + self, + ) -> Callable[ + [firestore_admin.CreateUserCredsRequest], Awaitable[gfa_user_creds.UserCreds] + ]: + r"""Return a callable for the create user creds method over gRPC. + + Create a user creds. + + Returns: + Callable[[~.CreateUserCredsRequest], + Awaitable[~.UserCreds]]: + 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_user_creds" not in self._stubs: + self._stubs["create_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/CreateUserCreds", + request_serializer=firestore_admin.CreateUserCredsRequest.serialize, + response_deserializer=gfa_user_creds.UserCreds.deserialize, + ) + return self._stubs["create_user_creds"] + + @property + def get_user_creds( + self, + ) -> Callable[ + [firestore_admin.GetUserCredsRequest], Awaitable[user_creds.UserCreds] + ]: + r"""Return a callable for the get user creds method over gRPC. + + Gets a user creds resource. Note that the returned + resource does not contain the secret value itself. + + Returns: + Callable[[~.GetUserCredsRequest], + Awaitable[~.UserCreds]]: + 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_user_creds" not in self._stubs: + self._stubs["get_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/GetUserCreds", + request_serializer=firestore_admin.GetUserCredsRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["get_user_creds"] + + @property + def list_user_creds( + self, + ) -> Callable[ + [firestore_admin.ListUserCredsRequest], + Awaitable[firestore_admin.ListUserCredsResponse], + ]: + r"""Return a callable for the list user creds method over gRPC. + + List all user creds in the database. Note that the + returned resource does not contain the secret value + itself. + + Returns: + Callable[[~.ListUserCredsRequest], + Awaitable[~.ListUserCredsResponse]]: + 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_user_creds" not in self._stubs: + self._stubs["list_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/ListUserCreds", + request_serializer=firestore_admin.ListUserCredsRequest.serialize, + response_deserializer=firestore_admin.ListUserCredsResponse.deserialize, + ) + return self._stubs["list_user_creds"] + + @property + def enable_user_creds( + self, + ) -> Callable[ + [firestore_admin.EnableUserCredsRequest], Awaitable[user_creds.UserCreds] + ]: + r"""Return a callable for the enable user creds method over gRPC. + + Enables a user creds. No-op if the user creds are + already enabled. + + Returns: + Callable[[~.EnableUserCredsRequest], + Awaitable[~.UserCreds]]: + 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 "enable_user_creds" not in self._stubs: + self._stubs["enable_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/EnableUserCreds", + request_serializer=firestore_admin.EnableUserCredsRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["enable_user_creds"] + + @property + def disable_user_creds( + self, + ) -> Callable[ + [firestore_admin.DisableUserCredsRequest], Awaitable[user_creds.UserCreds] + ]: + r"""Return a callable for the disable user creds method over gRPC. + + Disables a user creds. No-op if the user creds are + already disabled. + + Returns: + Callable[[~.DisableUserCredsRequest], + Awaitable[~.UserCreds]]: + 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 "disable_user_creds" not in self._stubs: + self._stubs["disable_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/DisableUserCreds", + request_serializer=firestore_admin.DisableUserCredsRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["disable_user_creds"] + + @property + def reset_user_password( + self, + ) -> Callable[ + [firestore_admin.ResetUserPasswordRequest], Awaitable[user_creds.UserCreds] + ]: + r"""Return a callable for the reset user password method over gRPC. + + Resets the password of a user creds. + + Returns: + Callable[[~.ResetUserPasswordRequest], + Awaitable[~.UserCreds]]: + 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 "reset_user_password" not in self._stubs: + self._stubs["reset_user_password"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/ResetUserPassword", + request_serializer=firestore_admin.ResetUserPasswordRequest.serialize, + response_deserializer=user_creds.UserCreds.deserialize, + ) + return self._stubs["reset_user_password"] + + @property + def delete_user_creds( + self, + ) -> Callable[[firestore_admin.DeleteUserCredsRequest], Awaitable[empty_pb2.Empty]]: + r"""Return a callable for the delete user creds method over gRPC. + + Deletes a user creds. + + Returns: + Callable[[~.DeleteUserCredsRequest], + 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_user_creds" not in self._stubs: + self._stubs["delete_user_creds"] = self._logged_channel.unary_unary( + "/google.firestore.admin.v1.FirestoreAdmin/DeleteUserCreds", + request_serializer=firestore_admin.DeleteUserCredsRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_user_creds"] + @property def get_backup( self, @@ -1262,6 +1464,41 @@ def _prep_wrapped_messages(self, client_info): default_timeout=None, client_info=client_info, ), + self.create_user_creds: self._wrap_method( + self.create_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.get_user_creds: self._wrap_method( + self.get_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.list_user_creds: self._wrap_method( + self.list_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.enable_user_creds: self._wrap_method( + self.enable_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.disable_user_creds: self._wrap_method( + self.disable_user_creds, + default_timeout=None, + client_info=client_info, + ), + self.reset_user_password: self._wrap_method( + self.reset_user_password, + default_timeout=None, + client_info=client_info, + ), + self.delete_user_creds: self._wrap_method( + self.delete_user_creds, + default_timeout=None, + client_info=client_info, + ), self.get_backup: self._wrap_method( self.get_backup, default_timeout=None, diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py index 94ef123c58..06ee1b9e3c 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py @@ -40,6 +40,8 @@ from google.cloud.firestore_admin_v1.types import firestore_admin from google.cloud.firestore_admin_v1.types import index from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.protobuf import empty_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore @@ -115,6 +117,14 @@ def post_create_index(self, response): logging.log(f"Received response: {response}") return response + def pre_create_user_creds(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_user_creds(self, response): + logging.log(f"Received response: {response}") + return response + def pre_delete_backup(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -135,6 +145,26 @@ def pre_delete_index(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata + def pre_delete_user_creds(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def pre_disable_user_creds(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_disable_user_creds(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_enable_user_creds(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_enable_user_creds(self, response): + logging.log(f"Received response: {response}") + return response + def pre_export_documents(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -183,6 +213,14 @@ def post_get_index(self, response): logging.log(f"Received response: {response}") return response + def pre_get_user_creds(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_user_creds(self, response): + logging.log(f"Received response: {response}") + return response + def pre_import_documents(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -231,6 +269,22 @@ def post_list_indexes(self, response): logging.log(f"Received response: {response}") return response + def pre_list_user_creds(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_user_creds(self, response): + logging.log(f"Received response: {response}") + return response + + def pre_reset_user_password(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_reset_user_password(self, response): + logging.log(f"Received response: {response}") + return response + def pre_restore_database(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -463,6 +517,54 @@ def post_create_index_with_metadata( """ return response, metadata + def pre_create_user_creds( + self, + request: firestore_admin.CreateUserCredsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.CreateUserCredsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for create_user_creds + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def post_create_user_creds( + self, response: gfa_user_creds.UserCreds + ) -> gfa_user_creds.UserCreds: + """Post-rpc interceptor for create_user_creds + + DEPRECATED. Please use the `post_create_user_creds_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the FirestoreAdmin server but before + it is returned to user code. This `post_create_user_creds` interceptor runs + before the `post_create_user_creds_with_metadata` interceptor. + """ + return response + + def post_create_user_creds_with_metadata( + self, + response: gfa_user_creds.UserCreds, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[gfa_user_creds.UserCreds, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for create_user_creds + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the FirestoreAdmin server but before it is returned to user code. + + We recommend only using this `post_create_user_creds_with_metadata` + interceptor in new development instead of the `post_create_user_creds` interceptor. + When both interceptors are used, this `post_create_user_creds_with_metadata` interceptor runs after the + `post_create_user_creds` interceptor. The (possibly modified) response returned by + `post_create_user_creds` will be passed to + `post_create_user_creds_with_metadata`. + """ + return response, metadata + def pre_delete_backup( self, request: firestore_admin.DeleteBackupRequest, @@ -554,6 +656,116 @@ def pre_delete_index( """ return request, metadata + def pre_delete_user_creds( + self, + request: firestore_admin.DeleteUserCredsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.DeleteUserCredsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for delete_user_creds + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def pre_disable_user_creds( + self, + request: firestore_admin.DisableUserCredsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.DisableUserCredsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for disable_user_creds + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def post_disable_user_creds( + self, response: user_creds.UserCreds + ) -> user_creds.UserCreds: + """Post-rpc interceptor for disable_user_creds + + DEPRECATED. Please use the `post_disable_user_creds_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the FirestoreAdmin server but before + it is returned to user code. This `post_disable_user_creds` interceptor runs + before the `post_disable_user_creds_with_metadata` interceptor. + """ + return response + + def post_disable_user_creds_with_metadata( + self, + response: user_creds.UserCreds, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[user_creds.UserCreds, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for disable_user_creds + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the FirestoreAdmin server but before it is returned to user code. + + We recommend only using this `post_disable_user_creds_with_metadata` + interceptor in new development instead of the `post_disable_user_creds` interceptor. + When both interceptors are used, this `post_disable_user_creds_with_metadata` interceptor runs after the + `post_disable_user_creds` interceptor. The (possibly modified) response returned by + `post_disable_user_creds` will be passed to + `post_disable_user_creds_with_metadata`. + """ + return response, metadata + + def pre_enable_user_creds( + self, + request: firestore_admin.EnableUserCredsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.EnableUserCredsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for enable_user_creds + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def post_enable_user_creds( + self, response: user_creds.UserCreds + ) -> user_creds.UserCreds: + """Post-rpc interceptor for enable_user_creds + + DEPRECATED. Please use the `post_enable_user_creds_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the FirestoreAdmin server but before + it is returned to user code. This `post_enable_user_creds` interceptor runs + before the `post_enable_user_creds_with_metadata` interceptor. + """ + return response + + def post_enable_user_creds_with_metadata( + self, + response: user_creds.UserCreds, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[user_creds.UserCreds, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for enable_user_creds + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the FirestoreAdmin server but before it is returned to user code. + + We recommend only using this `post_enable_user_creds_with_metadata` + interceptor in new development instead of the `post_enable_user_creds` interceptor. + When both interceptors are used, this `post_enable_user_creds_with_metadata` interceptor runs after the + `post_enable_user_creds` interceptor. The (possibly modified) response returned by + `post_enable_user_creds` will be passed to + `post_enable_user_creds_with_metadata`. + """ + return response, metadata + def pre_export_documents( self, request: firestore_admin.ExportDocumentsRequest, @@ -829,6 +1041,54 @@ def post_get_index_with_metadata( """ return response, metadata + def pre_get_user_creds( + self, + request: firestore_admin.GetUserCredsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.GetUserCredsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for get_user_creds + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def post_get_user_creds( + self, response: user_creds.UserCreds + ) -> user_creds.UserCreds: + """Post-rpc interceptor for get_user_creds + + DEPRECATED. Please use the `post_get_user_creds_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the FirestoreAdmin server but before + it is returned to user code. This `post_get_user_creds` interceptor runs + before the `post_get_user_creds_with_metadata` interceptor. + """ + return response + + def post_get_user_creds_with_metadata( + self, + response: user_creds.UserCreds, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[user_creds.UserCreds, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for get_user_creds + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the FirestoreAdmin server but before it is returned to user code. + + We recommend only using this `post_get_user_creds_with_metadata` + interceptor in new development instead of the `post_get_user_creds` interceptor. + When both interceptors are used, this `post_get_user_creds_with_metadata` interceptor runs after the + `post_get_user_creds` interceptor. The (possibly modified) response returned by + `post_get_user_creds` will be passed to + `post_get_user_creds_with_metadata`. + """ + return response, metadata + def pre_import_documents( self, request: firestore_admin.ImportDocumentsRequest, @@ -1129,6 +1389,105 @@ def post_list_indexes_with_metadata( """ return response, metadata + def pre_list_user_creds( + self, + request: firestore_admin.ListUserCredsRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.ListUserCredsRequest, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Pre-rpc interceptor for list_user_creds + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def post_list_user_creds( + self, response: firestore_admin.ListUserCredsResponse + ) -> firestore_admin.ListUserCredsResponse: + """Post-rpc interceptor for list_user_creds + + DEPRECATED. Please use the `post_list_user_creds_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the FirestoreAdmin server but before + it is returned to user code. This `post_list_user_creds` interceptor runs + before the `post_list_user_creds_with_metadata` interceptor. + """ + return response + + def post_list_user_creds_with_metadata( + self, + response: firestore_admin.ListUserCredsResponse, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.ListUserCredsResponse, Sequence[Tuple[str, Union[str, bytes]]] + ]: + """Post-rpc interceptor for list_user_creds + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the FirestoreAdmin server but before it is returned to user code. + + We recommend only using this `post_list_user_creds_with_metadata` + interceptor in new development instead of the `post_list_user_creds` interceptor. + When both interceptors are used, this `post_list_user_creds_with_metadata` interceptor runs after the + `post_list_user_creds` interceptor. The (possibly modified) response returned by + `post_list_user_creds` will be passed to + `post_list_user_creds_with_metadata`. + """ + return response, metadata + + def pre_reset_user_password( + self, + request: firestore_admin.ResetUserPasswordRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + firestore_admin.ResetUserPasswordRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for reset_user_password + + Override in a subclass to manipulate the request or metadata + before they are sent to the FirestoreAdmin server. + """ + return request, metadata + + def post_reset_user_password( + self, response: user_creds.UserCreds + ) -> user_creds.UserCreds: + """Post-rpc interceptor for reset_user_password + + DEPRECATED. Please use the `post_reset_user_password_with_metadata` + interceptor instead. + + Override in a subclass to read or manipulate the response + after it is returned by the FirestoreAdmin server but before + it is returned to user code. This `post_reset_user_password` interceptor runs + before the `post_reset_user_password_with_metadata` interceptor. + """ + return response + + def post_reset_user_password_with_metadata( + self, + response: user_creds.UserCreds, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[user_creds.UserCreds, Sequence[Tuple[str, Union[str, bytes]]]]: + """Post-rpc interceptor for reset_user_password + + Override in a subclass to read or manipulate the response or metadata after it + is returned by the FirestoreAdmin server but before it is returned to user code. + + We recommend only using this `post_reset_user_password_with_metadata` + interceptor in new development instead of the `post_reset_user_password` interceptor. + When both interceptors are used, this `post_reset_user_password_with_metadata` interceptor runs after the + `post_reset_user_password` interceptor. The (possibly modified) response returned by + `post_reset_user_password` will be passed to + `post_reset_user_password_with_metadata`. + """ + return response, metadata + def pre_restore_database( self, request: firestore_admin.RestoreDatabaseRequest, @@ -2216,11 +2575,11 @@ def __call__( ) return resp - class _DeleteBackup( - _BaseFirestoreAdminRestTransport._BaseDeleteBackup, FirestoreAdminRestStub + class _CreateUserCreds( + _BaseFirestoreAdminRestTransport._BaseCreateUserCreds, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.DeleteBackup") + return hash("FirestoreAdminRestTransport.CreateUserCreds") @staticmethod def _get_response( @@ -2241,23 +2600,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: firestore_admin.DeleteBackupRequest, + request: firestore_admin.CreateUserCredsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ): - r"""Call the delete backup method over HTTP. + ) -> gfa_user_creds.UserCreds: + r"""Call the create user creds method over HTTP. Args: - request (~.firestore_admin.DeleteBackupRequest): + request (~.firestore_admin.CreateUserCredsRequest): The request object. The request for - [FirestoreAdmin.DeleteBackup][google.firestore.admin.v1.FirestoreAdmin.DeleteBackup]. + [FirestoreAdmin.CreateUserCreds][google.firestore.admin.v1.FirestoreAdmin.CreateUserCreds]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -2265,19 +2625,29 @@ 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: + ~.gfa_user_creds.UserCreds: + A Cloud Firestore User Creds. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseDeleteBackup._get_http_options() + _BaseFirestoreAdminRestTransport._BaseCreateUserCreds._get_http_options() ) - request, metadata = self._interceptor.pre_delete_backup(request, metadata) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseDeleteBackup._get_transcoded_request( + request, metadata = self._interceptor.pre_create_user_creds( + request, metadata + ) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseCreateUserCreds._get_transcoded_request( http_options, request ) + body = _BaseFirestoreAdminRestTransport._BaseCreateUserCreds._get_request_body_json( + transcoded_request + ) + # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseDeleteBackup._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseCreateUserCreds._get_query_params_json( transcoded_request ) @@ -2289,7 +2659,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 = { @@ -2299,23 +2669,24 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.DeleteBackup", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.CreateUserCreds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "DeleteBackup", + "rpcName": "CreateUserCreds", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._DeleteBackup._get_response( + response = FirestoreAdminRestTransport._CreateUserCreds._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, + body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -2323,22 +2694,163 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) - class _DeleteBackupSchedule( - _BaseFirestoreAdminRestTransport._BaseDeleteBackupSchedule, - FirestoreAdminRestStub, - ): - def __hash__(self): - return hash("FirestoreAdminRestTransport.DeleteBackupSchedule") + # Return the response + resp = gfa_user_creds.UserCreds() + pb_resp = gfa_user_creds.UserCreds.pb(resp) - @staticmethod - def _get_response( - host, - metadata, - query_params, - session, - timeout, - transcoded_request, - body=None, + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_create_user_creds(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_create_user_creds_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = gfa_user_creds.UserCreds.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.firestore.admin_v1.FirestoreAdminClient.create_user_creds", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "CreateUserCreds", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _DeleteBackup( + _BaseFirestoreAdminRestTransport._BaseDeleteBackup, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.DeleteBackup") + + @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: firestore_admin.DeleteBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ): + r"""Call the delete backup method over HTTP. + + Args: + request (~.firestore_admin.DeleteBackupRequest): + The request object. The request for + [FirestoreAdmin.DeleteBackup][google.firestore.admin.v1.FirestoreAdmin.DeleteBackup]. + 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 = ( + _BaseFirestoreAdminRestTransport._BaseDeleteBackup._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_backup(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseDeleteBackup._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseFirestoreAdminRestTransport._BaseDeleteBackup._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.firestore.admin_v1.FirestoreAdminClient.DeleteBackup", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "DeleteBackup", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._DeleteBackup._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 _DeleteBackupSchedule( + _BaseFirestoreAdminRestTransport._BaseDeleteBackupSchedule, + FirestoreAdminRestStub, + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.DeleteBackupSchedule") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, ): uri = transcoded_request["uri"] method = transcoded_request["method"] @@ -2686,11 +3198,11 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) - class _ExportDocuments( - _BaseFirestoreAdminRestTransport._BaseExportDocuments, FirestoreAdminRestStub + class _DeleteUserCreds( + _BaseFirestoreAdminRestTransport._BaseDeleteUserCreds, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ExportDocuments") + return hash("FirestoreAdminRestTransport.DeleteUserCreds") @staticmethod def _get_response( @@ -2711,24 +3223,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: firestore_admin.ExportDocumentsRequest, + request: firestore_admin.DeleteUserCredsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> operations_pb2.Operation: - r"""Call the export documents method over HTTP. + ): + r"""Call the delete user creds method over HTTP. Args: - request (~.firestore_admin.ExportDocumentsRequest): + request (~.firestore_admin.DeleteUserCredsRequest): The request object. The request for - [FirestoreAdmin.ExportDocuments][google.firestore.admin.v1.FirestoreAdmin.ExportDocuments]. + [FirestoreAdmin.DeleteUserCreds][google.firestore.admin.v1.FirestoreAdmin.DeleteUserCreds]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -2736,32 +3247,21 @@ 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: - ~.operations_pb2.Operation: - This resource represents a - long-running operation that is the - result of a network API call. - """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_http_options() + _BaseFirestoreAdminRestTransport._BaseDeleteUserCreds._get_http_options() ) - request, metadata = self._interceptor.pre_export_documents( + request, metadata = self._interceptor.pre_delete_user_creds( request, metadata ) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_transcoded_request( + transcoded_request = _BaseFirestoreAdminRestTransport._BaseDeleteUserCreds._get_transcoded_request( http_options, request ) - body = _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_request_body_json( - transcoded_request - ) - # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseDeleteUserCreds._get_query_params_json( transcoded_request ) @@ -2783,24 +3283,23 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ExportDocuments", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.DeleteUserCreds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ExportDocuments", + "rpcName": "DeleteUserCreds", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ExportDocuments._get_response( + response = FirestoreAdminRestTransport._DeleteUserCreds._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, - body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -2808,43 +3307,11 @@ def __call__( if response.status_code >= 400: raise core_exceptions.from_http_response(response) - # Return the response - resp = operations_pb2.Operation() - json_format.Parse(response.content, resp, ignore_unknown_fields=True) - - resp = self._interceptor.post_export_documents(resp) - response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_export_documents_with_metadata( - resp, response_metadata - ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( - logging.DEBUG - ): # pragma: NO COVER - try: - response_payload = json_format.MessageToJson(resp) - except: - response_payload = None - http_response = { - "payload": response_payload, - "headers": dict(response.headers), - "status": response.status_code, - } - _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.export_documents", - extra={ - "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ExportDocuments", - "metadata": http_response["headers"], - "httpResponse": http_response, - }, - ) - return resp - - class _GetBackup( - _BaseFirestoreAdminRestTransport._BaseGetBackup, FirestoreAdminRestStub + class _DisableUserCreds( + _BaseFirestoreAdminRestTransport._BaseDisableUserCreds, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.GetBackup") + return hash("FirestoreAdminRestTransport.DisableUserCreds") @staticmethod def _get_response( @@ -2865,23 +3332,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: firestore_admin.GetBackupRequest, + request: firestore_admin.DisableUserCredsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> backup.Backup: - r"""Call the get backup method over HTTP. + ) -> user_creds.UserCreds: + r"""Call the disable user creds method over HTTP. Args: - request (~.firestore_admin.GetBackupRequest): + request (~.firestore_admin.DisableUserCredsRequest): The request object. The request for - [FirestoreAdmin.GetBackup][google.firestore.admin.v1.FirestoreAdmin.GetBackup]. + [FirestoreAdmin.DisableUserCreds][google.firestore.admin.v1.FirestoreAdmin.DisableUserCreds]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -2891,31 +3359,28 @@ def __call__( be of type `bytes`. Returns: - ~.backup.Backup: - A Backup of a Cloud Firestore - Database. - The backup contains all documents and - index configurations for the given - database at a specific point in time. - + ~.user_creds.UserCreds: + A Cloud Firestore User Creds. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseGetBackup._get_http_options() + _BaseFirestoreAdminRestTransport._BaseDisableUserCreds._get_http_options() ) - request, metadata = self._interceptor.pre_get_backup(request, metadata) - transcoded_request = ( - _BaseFirestoreAdminRestTransport._BaseGetBackup._get_transcoded_request( - http_options, request - ) + request, metadata = self._interceptor.pre_disable_user_creds( + request, metadata + ) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseDisableUserCreds._get_transcoded_request( + http_options, request + ) + + body = _BaseFirestoreAdminRestTransport._BaseDisableUserCreds._get_request_body_json( + transcoded_request ) # Jsonify the query params - query_params = ( - _BaseFirestoreAdminRestTransport._BaseGetBackup._get_query_params_json( - transcoded_request - ) + query_params = _BaseFirestoreAdminRestTransport._BaseDisableUserCreds._get_query_params_json( + transcoded_request ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( @@ -2936,23 +3401,24 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetBackup", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.DisableUserCreds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetBackup", + "rpcName": "DisableUserCreds", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._GetBackup._get_response( + response = FirestoreAdminRestTransport._DisableUserCreds._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, + body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -2961,21 +3427,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = backup.Backup() - pb_resp = backup.Backup.pb(resp) + resp = user_creds.UserCreds() + pb_resp = user_creds.UserCreds.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_backup(resp) + resp = self._interceptor.post_disable_user_creds(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_backup_with_metadata( + resp, _ = self._interceptor.post_disable_user_creds_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = backup.Backup.to_json(response) + response_payload = user_creds.UserCreds.to_json(response) except: response_payload = None http_response = { @@ -2984,21 +3450,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_backup", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.disable_user_creds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetBackup", + "rpcName": "DisableUserCreds", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _GetBackupSchedule( - _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule, FirestoreAdminRestStub + class _EnableUserCreds( + _BaseFirestoreAdminRestTransport._BaseEnableUserCreds, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.GetBackupSchedule") + return hash("FirestoreAdminRestTransport.EnableUserCreds") @staticmethod def _get_response( @@ -3019,23 +3485,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: firestore_admin.GetBackupScheduleRequest, + request: firestore_admin.EnableUserCredsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> schedule.BackupSchedule: - r"""Call the get backup schedule method over HTTP. + ) -> user_creds.UserCreds: + r"""Call the enable user creds method over HTTP. Args: - request (~.firestore_admin.GetBackupScheduleRequest): + request (~.firestore_admin.EnableUserCredsRequest): The request object. The request for - [FirestoreAdmin.GetBackupSchedule][google.firestore.admin.v1.FirestoreAdmin.GetBackupSchedule]. + [FirestoreAdmin.EnableUserCreds][google.firestore.admin.v1.FirestoreAdmin.EnableUserCreds]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3045,30 +3512,941 @@ def __call__( be of type `bytes`. Returns: - ~.schedule.BackupSchedule: - A backup schedule for a Cloud - Firestore Database. - This resource is owned by the database - it is backing up, and is deleted along - with the database. The actual backups - are not though. + ~.user_creds.UserCreds: + A Cloud Firestore User Creds. + """ + + http_options = ( + _BaseFirestoreAdminRestTransport._BaseEnableUserCreds._get_http_options() + ) + + request, metadata = self._interceptor.pre_enable_user_creds( + request, metadata + ) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseEnableUserCreds._get_transcoded_request( + http_options, request + ) + + body = _BaseFirestoreAdminRestTransport._BaseEnableUserCreds._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseFirestoreAdminRestTransport._BaseEnableUserCreds._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.firestore.admin_v1.FirestoreAdminClient.EnableUserCreds", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "EnableUserCreds", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._EnableUserCreds._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 = user_creds.UserCreds() + pb_resp = user_creds.UserCreds.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_enable_user_creds(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_enable_user_creds_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = user_creds.UserCreds.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.firestore.admin_v1.FirestoreAdminClient.enable_user_creds", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "EnableUserCreds", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _ExportDocuments( + _BaseFirestoreAdminRestTransport._BaseExportDocuments, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.ExportDocuments") + + @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: firestore_admin.ExportDocumentsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> operations_pb2.Operation: + r"""Call the export documents method over HTTP. + + Args: + request (~.firestore_admin.ExportDocumentsRequest): + The request object. The request for + [FirestoreAdmin.ExportDocuments][google.firestore.admin.v1.FirestoreAdmin.ExportDocuments]. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be + sent along with the request as metadata. Normally, each value must be of type `str`, + but for metadata keys ending with the suffix `-bin`, the corresponding values must + be of type `bytes`. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule._get_http_options() + _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_http_options() ) - request, metadata = self._interceptor.pre_get_backup_schedule( + request, metadata = self._interceptor.pre_export_documents( request, metadata ) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule._get_transcoded_request( + transcoded_request = _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_transcoded_request( http_options, request ) + body = _BaseFirestoreAdminRestTransport._BaseExportDocuments._get_request_body_json( + transcoded_request + ) + + # Jsonify the query params + query_params = _BaseFirestoreAdminRestTransport._BaseExportDocuments._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.firestore.admin_v1.FirestoreAdminClient.ExportDocuments", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "ExportDocuments", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._ExportDocuments._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_export_documents(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_export_documents_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = json_format.MessageToJson(resp) + except: + response_payload = None + http_response = { + "payload": response_payload, + "headers": dict(response.headers), + "status": response.status_code, + } + _LOGGER.debug( + "Received response for google.firestore.admin_v1.FirestoreAdminClient.export_documents", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "ExportDocuments", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetBackup( + _BaseFirestoreAdminRestTransport._BaseGetBackup, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.GetBackup") + + @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: firestore_admin.GetBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> backup.Backup: + r"""Call the get backup method over HTTP. + + Args: + request (~.firestore_admin.GetBackupRequest): + The request object. The request for + [FirestoreAdmin.GetBackup][google.firestore.admin.v1.FirestoreAdmin.GetBackup]. + 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: + ~.backup.Backup: + A Backup of a Cloud Firestore + Database. + The backup contains all documents and + index configurations for the given + database at a specific point in time. + + """ + + http_options = ( + _BaseFirestoreAdminRestTransport._BaseGetBackup._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_backup(request, metadata) + transcoded_request = ( + _BaseFirestoreAdminRestTransport._BaseGetBackup._get_transcoded_request( + http_options, request + ) + ) + + # Jsonify the query params + query_params = ( + _BaseFirestoreAdminRestTransport._BaseGetBackup._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.firestore.admin_v1.FirestoreAdminClient.GetBackup", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetBackup", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._GetBackup._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 = backup.Backup() + pb_resp = backup.Backup.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_get_backup(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_get_backup_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = backup.Backup.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.firestore.admin_v1.FirestoreAdminClient.get_backup", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetBackup", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetBackupSchedule( + _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.GetBackupSchedule") + + @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: firestore_admin.GetBackupScheduleRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> schedule.BackupSchedule: + r"""Call the get backup schedule method over HTTP. + + Args: + request (~.firestore_admin.GetBackupScheduleRequest): + The request object. The request for + [FirestoreAdmin.GetBackupSchedule][google.firestore.admin.v1.FirestoreAdmin.GetBackupSchedule]. + 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: + ~.schedule.BackupSchedule: + A backup schedule for a Cloud + Firestore Database. + This resource is owned by the database + it is backing up, and is deleted along + with the database. The actual backups + are not though. + + """ + + http_options = ( + _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_backup_schedule( + request, metadata + ) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule._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.firestore.admin_v1.FirestoreAdminClient.GetBackupSchedule", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetBackupSchedule", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._GetBackupSchedule._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 = schedule.BackupSchedule() + pb_resp = schedule.BackupSchedule.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_get_backup_schedule(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_get_backup_schedule_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = schedule.BackupSchedule.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.firestore.admin_v1.FirestoreAdminClient.get_backup_schedule", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetBackupSchedule", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetDatabase( + _BaseFirestoreAdminRestTransport._BaseGetDatabase, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.GetDatabase") + + @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: firestore_admin.GetDatabaseRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> database.Database: + r"""Call the get database method over HTTP. + + Args: + request (~.firestore_admin.GetDatabaseRequest): + The request object. The request for + [FirestoreAdmin.GetDatabase][google.firestore.admin.v1.FirestoreAdmin.GetDatabase]. + 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: + ~.database.Database: + A Cloud Firestore Database. + """ + + http_options = ( + _BaseFirestoreAdminRestTransport._BaseGetDatabase._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_database(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseGetDatabase._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseFirestoreAdminRestTransport._BaseGetDatabase._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.firestore.admin_v1.FirestoreAdminClient.GetDatabase", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetDatabase", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._GetDatabase._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 = database.Database() + pb_resp = database.Database.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_get_database(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_get_database_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = database.Database.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.firestore.admin_v1.FirestoreAdminClient.get_database", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetDatabase", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetField( + _BaseFirestoreAdminRestTransport._BaseGetField, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.GetField") + + @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: firestore_admin.GetFieldRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> field.Field: + r"""Call the get field method over HTTP. + + Args: + request (~.firestore_admin.GetFieldRequest): + The request object. The request for + [FirestoreAdmin.GetField][google.firestore.admin.v1.FirestoreAdmin.GetField]. + 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: + ~.field.Field: + Represents a single field in the + database. + Fields are grouped by their "Collection + Group", which represent all collections + in the database with the same ID. + + """ + + http_options = ( + _BaseFirestoreAdminRestTransport._BaseGetField._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_field(request, metadata) + transcoded_request = ( + _BaseFirestoreAdminRestTransport._BaseGetField._get_transcoded_request( + http_options, request + ) + ) + + # Jsonify the query params + query_params = ( + _BaseFirestoreAdminRestTransport._BaseGetField._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.firestore.admin_v1.FirestoreAdminClient.GetField", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetField", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = FirestoreAdminRestTransport._GetField._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 = field.Field() + pb_resp = field.Field.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_get_field(resp) + response_metadata = [(k, str(v)) for k, v in response.headers.items()] + resp, _ = self._interceptor.post_get_field_with_metadata( + resp, response_metadata + ) + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( + logging.DEBUG + ): # pragma: NO COVER + try: + response_payload = field.Field.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.firestore.admin_v1.FirestoreAdminClient.get_field", + extra={ + "serviceName": "google.firestore.admin.v1.FirestoreAdmin", + "rpcName": "GetField", + "metadata": http_response["headers"], + "httpResponse": http_response, + }, + ) + return resp + + class _GetIndex( + _BaseFirestoreAdminRestTransport._BaseGetIndex, FirestoreAdminRestStub + ): + def __hash__(self): + return hash("FirestoreAdminRestTransport.GetIndex") + + @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: firestore_admin.GetIndexRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> index.Index: + r"""Call the get index method over HTTP. + + Args: + request (~.firestore_admin.GetIndexRequest): + The request object. The request for + [FirestoreAdmin.GetIndex][google.firestore.admin.v1.FirestoreAdmin.GetIndex]. + 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: + ~.index.Index: + Cloud Firestore indexes enable simple + and complex queries against documents in + a database. + + """ + + http_options = ( + _BaseFirestoreAdminRestTransport._BaseGetIndex._get_http_options() + ) + + request, metadata = self._interceptor.pre_get_index(request, metadata) + transcoded_request = ( + _BaseFirestoreAdminRestTransport._BaseGetIndex._get_transcoded_request( + http_options, request + ) + ) + # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseGetBackupSchedule._get_query_params_json( - transcoded_request + query_params = ( + _BaseFirestoreAdminRestTransport._BaseGetIndex._get_query_params_json( + transcoded_request + ) ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( @@ -3089,17 +4467,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetBackupSchedule", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetIndex", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetBackupSchedule", + "rpcName": "GetIndex", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._GetBackupSchedule._get_response( + response = FirestoreAdminRestTransport._GetIndex._get_response( self._host, metadata, query_params, @@ -3114,21 +4492,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = schedule.BackupSchedule() - pb_resp = schedule.BackupSchedule.pb(resp) + resp = index.Index() + pb_resp = index.Index.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_backup_schedule(resp) + resp = self._interceptor.post_get_index(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_backup_schedule_with_metadata( + resp, _ = self._interceptor.post_get_index_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = schedule.BackupSchedule.to_json(response) + response_payload = index.Index.to_json(response) except: response_payload = None http_response = { @@ -3137,21 +4515,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_backup_schedule", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_index", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetBackupSchedule", + "rpcName": "GetIndex", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _GetDatabase( - _BaseFirestoreAdminRestTransport._BaseGetDatabase, FirestoreAdminRestStub + class _GetUserCreds( + _BaseFirestoreAdminRestTransport._BaseGetUserCreds, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.GetDatabase") + return hash("FirestoreAdminRestTransport.GetUserCreds") @staticmethod def _get_response( @@ -3177,18 +4555,18 @@ def _get_response( def __call__( self, - request: firestore_admin.GetDatabaseRequest, + request: firestore_admin.GetUserCredsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> database.Database: - r"""Call the get database method over HTTP. + ) -> user_creds.UserCreds: + r"""Call the get user creds method over HTTP. Args: - request (~.firestore_admin.GetDatabaseRequest): + request (~.firestore_admin.GetUserCredsRequest): The request object. The request for - [FirestoreAdmin.GetDatabase][google.firestore.admin.v1.FirestoreAdmin.GetDatabase]. + [FirestoreAdmin.GetUserCreds][google.firestore.admin.v1.FirestoreAdmin.GetUserCreds]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3198,21 +4576,21 @@ def __call__( be of type `bytes`. Returns: - ~.database.Database: - A Cloud Firestore Database. + ~.user_creds.UserCreds: + A Cloud Firestore User Creds. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseGetDatabase._get_http_options() + _BaseFirestoreAdminRestTransport._BaseGetUserCreds._get_http_options() ) - request, metadata = self._interceptor.pre_get_database(request, metadata) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseGetDatabase._get_transcoded_request( + request, metadata = self._interceptor.pre_get_user_creds(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseGetUserCreds._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseGetDatabase._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseGetUserCreds._get_query_params_json( transcoded_request ) @@ -3234,17 +4612,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetDatabase", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetUserCreds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetDatabase", + "rpcName": "GetUserCreds", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._GetDatabase._get_response( + response = FirestoreAdminRestTransport._GetUserCreds._get_response( self._host, metadata, query_params, @@ -3259,21 +4637,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = database.Database() - pb_resp = database.Database.pb(resp) + resp = user_creds.UserCreds() + pb_resp = user_creds.UserCreds.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_database(resp) + resp = self._interceptor.post_get_user_creds(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_database_with_metadata( + resp, _ = self._interceptor.post_get_user_creds_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = database.Database.to_json(response) + response_payload = user_creds.UserCreds.to_json(response) except: response_payload = None http_response = { @@ -3282,21 +4660,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_database", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_user_creds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetDatabase", + "rpcName": "GetUserCreds", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _GetField( - _BaseFirestoreAdminRestTransport._BaseGetField, FirestoreAdminRestStub + class _ImportDocuments( + _BaseFirestoreAdminRestTransport._BaseImportDocuments, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.GetField") + return hash("FirestoreAdminRestTransport.ImportDocuments") @staticmethod def _get_response( @@ -3317,23 +4695,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: firestore_admin.GetFieldRequest, + request: firestore_admin.ImportDocumentsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> field.Field: - r"""Call the get field method over HTTP. + ) -> operations_pb2.Operation: + r"""Call the import documents method over HTTP. Args: - request (~.firestore_admin.GetFieldRequest): + request (~.firestore_admin.ImportDocumentsRequest): The request object. The request for - [FirestoreAdmin.GetField][google.firestore.admin.v1.FirestoreAdmin.GetField]. + [FirestoreAdmin.ImportDocuments][google.firestore.admin.v1.FirestoreAdmin.ImportDocuments]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3343,31 +4722,31 @@ def __call__( be of type `bytes`. Returns: - ~.field.Field: - Represents a single field in the - database. - Fields are grouped by their "Collection - Group", which represent all collections - in the database with the same ID. + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseGetField._get_http_options() + _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_http_options() ) - request, metadata = self._interceptor.pre_get_field(request, metadata) - transcoded_request = ( - _BaseFirestoreAdminRestTransport._BaseGetField._get_transcoded_request( - http_options, request - ) + request, metadata = self._interceptor.pre_import_documents( + request, metadata + ) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_transcoded_request( + http_options, request + ) + + body = _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_request_body_json( + transcoded_request ) # Jsonify the query params - query_params = ( - _BaseFirestoreAdminRestTransport._BaseGetField._get_query_params_json( - transcoded_request - ) + query_params = _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_query_params_json( + transcoded_request ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( @@ -3378,7 +4757,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 = { @@ -3388,23 +4767,24 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetField", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ImportDocuments", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetField", + "rpcName": "ImportDocuments", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._GetField._get_response( + response = FirestoreAdminRestTransport._ImportDocuments._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, + body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -3413,21 +4793,19 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = field.Field() - pb_resp = field.Field.pb(resp) - - json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_field(resp) + resp = self._interceptor.post_import_documents(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_field_with_metadata( + resp, _ = self._interceptor.post_import_documents_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = field.Field.to_json(response) + response_payload = json_format.MessageToJson(resp) except: response_payload = None http_response = { @@ -3436,21 +4814,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_field", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.import_documents", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetField", + "rpcName": "ImportDocuments", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _GetIndex( - _BaseFirestoreAdminRestTransport._BaseGetIndex, FirestoreAdminRestStub + class _ListBackups( + _BaseFirestoreAdminRestTransport._BaseListBackups, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.GetIndex") + return hash("FirestoreAdminRestTransport.ListBackups") @staticmethod def _get_response( @@ -3476,18 +4854,18 @@ def _get_response( def __call__( self, - request: firestore_admin.GetIndexRequest, + request: firestore_admin.ListBackupsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> index.Index: - r"""Call the get index method over HTTP. + ) -> firestore_admin.ListBackupsResponse: + r"""Call the list backups method over HTTP. Args: - request (~.firestore_admin.GetIndexRequest): + request (~.firestore_admin.ListBackupsRequest): The request object. The request for - [FirestoreAdmin.GetIndex][google.firestore.admin.v1.FirestoreAdmin.GetIndex]. + [FirestoreAdmin.ListBackups][google.firestore.admin.v1.FirestoreAdmin.ListBackups]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3497,29 +4875,24 @@ def __call__( be of type `bytes`. Returns: - ~.index.Index: - Cloud Firestore indexes enable simple - and complex queries against documents in - a database. + ~.firestore_admin.ListBackupsResponse: + The response for + [FirestoreAdmin.ListBackups][google.firestore.admin.v1.FirestoreAdmin.ListBackups]. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseGetIndex._get_http_options() + _BaseFirestoreAdminRestTransport._BaseListBackups._get_http_options() ) - request, metadata = self._interceptor.pre_get_index(request, metadata) - transcoded_request = ( - _BaseFirestoreAdminRestTransport._BaseGetIndex._get_transcoded_request( - http_options, request - ) + request, metadata = self._interceptor.pre_list_backups(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseListBackups._get_transcoded_request( + http_options, request ) # Jsonify the query params - query_params = ( - _BaseFirestoreAdminRestTransport._BaseGetIndex._get_query_params_json( - transcoded_request - ) + query_params = _BaseFirestoreAdminRestTransport._BaseListBackups._get_query_params_json( + transcoded_request ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( @@ -3540,17 +4913,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.GetIndex", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListBackups", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetIndex", + "rpcName": "ListBackups", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._GetIndex._get_response( + response = FirestoreAdminRestTransport._ListBackups._get_response( self._host, metadata, query_params, @@ -3565,21 +4938,23 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = index.Index() - pb_resp = index.Index.pb(resp) + resp = firestore_admin.ListBackupsResponse() + pb_resp = firestore_admin.ListBackupsResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_get_index(resp) + resp = self._interceptor.post_list_backups(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_get_index_with_metadata( + resp, _ = self._interceptor.post_list_backups_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = index.Index.to_json(response) + response_payload = firestore_admin.ListBackupsResponse.to_json( + response + ) except: response_payload = None http_response = { @@ -3588,21 +4963,22 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.get_index", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_backups", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "GetIndex", + "rpcName": "ListBackups", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ImportDocuments( - _BaseFirestoreAdminRestTransport._BaseImportDocuments, FirestoreAdminRestStub + class _ListBackupSchedules( + _BaseFirestoreAdminRestTransport._BaseListBackupSchedules, + FirestoreAdminRestStub, ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ImportDocuments") + return hash("FirestoreAdminRestTransport.ListBackupSchedules") @staticmethod def _get_response( @@ -3623,24 +4999,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: firestore_admin.ImportDocumentsRequest, + request: firestore_admin.ListBackupSchedulesRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> operations_pb2.Operation: - r"""Call the import documents method over HTTP. + ) -> firestore_admin.ListBackupSchedulesResponse: + r"""Call the list backup schedules method over HTTP. Args: - request (~.firestore_admin.ImportDocumentsRequest): + request (~.firestore_admin.ListBackupSchedulesRequest): The request object. The request for - [FirestoreAdmin.ImportDocuments][google.firestore.admin.v1.FirestoreAdmin.ImportDocuments]. + [FirestoreAdmin.ListBackupSchedules][google.firestore.admin.v1.FirestoreAdmin.ListBackupSchedules]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3650,30 +5025,25 @@ def __call__( be of type `bytes`. Returns: - ~.operations_pb2.Operation: - This resource represents a - long-running operation that is the - result of a network API call. + ~.firestore_admin.ListBackupSchedulesResponse: + The response for + [FirestoreAdmin.ListBackupSchedules][google.firestore.admin.v1.FirestoreAdmin.ListBackupSchedules]. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_http_options() + _BaseFirestoreAdminRestTransport._BaseListBackupSchedules._get_http_options() ) - request, metadata = self._interceptor.pre_import_documents( + request, metadata = self._interceptor.pre_list_backup_schedules( request, metadata ) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_transcoded_request( + transcoded_request = _BaseFirestoreAdminRestTransport._BaseListBackupSchedules._get_transcoded_request( http_options, request ) - body = _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_request_body_json( - transcoded_request - ) - # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseImportDocuments._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseListBackupSchedules._get_query_params_json( transcoded_request ) @@ -3685,7 +5055,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 = { @@ -3695,24 +5065,23 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ImportDocuments", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListBackupSchedules", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ImportDocuments", + "rpcName": "ListBackupSchedules", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ImportDocuments._get_response( + response = FirestoreAdminRestTransport._ListBackupSchedules._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, - body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -3721,19 +5090,23 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = operations_pb2.Operation() - json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = firestore_admin.ListBackupSchedulesResponse() + pb_resp = firestore_admin.ListBackupSchedulesResponse.pb(resp) - resp = self._interceptor.post_import_documents(resp) + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + + resp = self._interceptor.post_list_backup_schedules(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_import_documents_with_metadata( + resp, _ = self._interceptor.post_list_backup_schedules_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = json_format.MessageToJson(resp) + response_payload = ( + firestore_admin.ListBackupSchedulesResponse.to_json(response) + ) except: response_payload = None http_response = { @@ -3742,21 +5115,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.import_documents", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_backup_schedules", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ImportDocuments", + "rpcName": "ListBackupSchedules", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListBackups( - _BaseFirestoreAdminRestTransport._BaseListBackups, FirestoreAdminRestStub + class _ListDatabases( + _BaseFirestoreAdminRestTransport._BaseListDatabases, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ListBackups") + return hash("FirestoreAdminRestTransport.ListDatabases") @staticmethod def _get_response( @@ -3782,18 +5155,19 @@ def _get_response( def __call__( self, - request: firestore_admin.ListBackupsRequest, + request: firestore_admin.ListDatabasesRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> firestore_admin.ListBackupsResponse: - r"""Call the list backups method over HTTP. + ) -> firestore_admin.ListDatabasesResponse: + r"""Call the list databases method over HTTP. Args: - request (~.firestore_admin.ListBackupsRequest): - The request object. The request for - [FirestoreAdmin.ListBackups][google.firestore.admin.v1.FirestoreAdmin.ListBackups]. + request (~.firestore_admin.ListDatabasesRequest): + The request object. A request to list the Firestore + Databases in all locations for a + project. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3803,23 +5177,21 @@ def __call__( be of type `bytes`. Returns: - ~.firestore_admin.ListBackupsResponse: - The response for - [FirestoreAdmin.ListBackups][google.firestore.admin.v1.FirestoreAdmin.ListBackups]. - + ~.firestore_admin.ListDatabasesResponse: + The list of databases for a project. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseListBackups._get_http_options() + _BaseFirestoreAdminRestTransport._BaseListDatabases._get_http_options() ) - request, metadata = self._interceptor.pre_list_backups(request, metadata) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseListBackups._get_transcoded_request( + request, metadata = self._interceptor.pre_list_databases(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseListDatabases._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseListBackups._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseListDatabases._get_query_params_json( transcoded_request ) @@ -3841,17 +5213,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListBackups", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListDatabases", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListBackups", + "rpcName": "ListDatabases", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ListBackups._get_response( + response = FirestoreAdminRestTransport._ListDatabases._get_response( self._host, metadata, query_params, @@ -3866,21 +5238,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = firestore_admin.ListBackupsResponse() - pb_resp = firestore_admin.ListBackupsResponse.pb(resp) + resp = firestore_admin.ListDatabasesResponse() + pb_resp = firestore_admin.ListDatabasesResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_backups(resp) + resp = self._interceptor.post_list_databases(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_backups_with_metadata( + resp, _ = self._interceptor.post_list_databases_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = firestore_admin.ListBackupsResponse.to_json( + response_payload = firestore_admin.ListDatabasesResponse.to_json( response ) except: @@ -3891,22 +5263,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_backups", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_databases", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListBackups", + "rpcName": "ListDatabases", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListBackupSchedules( - _BaseFirestoreAdminRestTransport._BaseListBackupSchedules, - FirestoreAdminRestStub, + class _ListFields( + _BaseFirestoreAdminRestTransport._BaseListFields, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ListBackupSchedules") + return hash("FirestoreAdminRestTransport.ListFields") @staticmethod def _get_response( @@ -3932,18 +5303,18 @@ def _get_response( def __call__( self, - request: firestore_admin.ListBackupSchedulesRequest, + request: firestore_admin.ListFieldsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> firestore_admin.ListBackupSchedulesResponse: - r"""Call the list backup schedules method over HTTP. + ) -> firestore_admin.ListFieldsResponse: + r"""Call the list fields method over HTTP. Args: - request (~.firestore_admin.ListBackupSchedulesRequest): + request (~.firestore_admin.ListFieldsRequest): The request object. The request for - [FirestoreAdmin.ListBackupSchedules][google.firestore.admin.v1.FirestoreAdmin.ListBackupSchedules]. + [FirestoreAdmin.ListFields][google.firestore.admin.v1.FirestoreAdmin.ListFields]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -3953,26 +5324,26 @@ def __call__( be of type `bytes`. Returns: - ~.firestore_admin.ListBackupSchedulesResponse: + ~.firestore_admin.ListFieldsResponse: The response for - [FirestoreAdmin.ListBackupSchedules][google.firestore.admin.v1.FirestoreAdmin.ListBackupSchedules]. + [FirestoreAdmin.ListFields][google.firestore.admin.v1.FirestoreAdmin.ListFields]. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseListBackupSchedules._get_http_options() + _BaseFirestoreAdminRestTransport._BaseListFields._get_http_options() ) - request, metadata = self._interceptor.pre_list_backup_schedules( - request, metadata - ) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseListBackupSchedules._get_transcoded_request( + request, metadata = self._interceptor.pre_list_fields(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseListFields._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseListBackupSchedules._get_query_params_json( - transcoded_request + query_params = ( + _BaseFirestoreAdminRestTransport._BaseListFields._get_query_params_json( + transcoded_request + ) ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( @@ -3993,17 +5364,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListBackupSchedules", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListFields", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListBackupSchedules", + "rpcName": "ListFields", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ListBackupSchedules._get_response( + response = FirestoreAdminRestTransport._ListFields._get_response( self._host, metadata, query_params, @@ -4018,22 +5389,22 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = firestore_admin.ListBackupSchedulesResponse() - pb_resp = firestore_admin.ListBackupSchedulesResponse.pb(resp) + resp = firestore_admin.ListFieldsResponse() + pb_resp = firestore_admin.ListFieldsResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_backup_schedules(resp) + resp = self._interceptor.post_list_fields(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_backup_schedules_with_metadata( + resp, _ = self._interceptor.post_list_fields_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = ( - firestore_admin.ListBackupSchedulesResponse.to_json(response) + response_payload = firestore_admin.ListFieldsResponse.to_json( + response ) except: response_payload = None @@ -4043,21 +5414,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_backup_schedules", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_fields", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListBackupSchedules", + "rpcName": "ListFields", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListDatabases( - _BaseFirestoreAdminRestTransport._BaseListDatabases, FirestoreAdminRestStub + class _ListIndexes( + _BaseFirestoreAdminRestTransport._BaseListIndexes, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ListDatabases") + return hash("FirestoreAdminRestTransport.ListIndexes") @staticmethod def _get_response( @@ -4083,19 +5454,18 @@ def _get_response( def __call__( self, - request: firestore_admin.ListDatabasesRequest, + request: firestore_admin.ListIndexesRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> firestore_admin.ListDatabasesResponse: - r"""Call the list databases method over HTTP. + ) -> firestore_admin.ListIndexesResponse: + r"""Call the list indexes method over HTTP. Args: - request (~.firestore_admin.ListDatabasesRequest): - The request object. A request to list the Firestore - Databases in all locations for a - project. + request (~.firestore_admin.ListIndexesRequest): + The request object. The request for + [FirestoreAdmin.ListIndexes][google.firestore.admin.v1.FirestoreAdmin.ListIndexes]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -4105,21 +5475,23 @@ def __call__( be of type `bytes`. Returns: - ~.firestore_admin.ListDatabasesResponse: - The list of databases for a project. + ~.firestore_admin.ListIndexesResponse: + The response for + [FirestoreAdmin.ListIndexes][google.firestore.admin.v1.FirestoreAdmin.ListIndexes]. + """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseListDatabases._get_http_options() + _BaseFirestoreAdminRestTransport._BaseListIndexes._get_http_options() ) - request, metadata = self._interceptor.pre_list_databases(request, metadata) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseListDatabases._get_transcoded_request( + request, metadata = self._interceptor.pre_list_indexes(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseListIndexes._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseListDatabases._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseListIndexes._get_query_params_json( transcoded_request ) @@ -4141,17 +5513,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListDatabases", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListIndexes", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListDatabases", + "rpcName": "ListIndexes", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ListDatabases._get_response( + response = FirestoreAdminRestTransport._ListIndexes._get_response( self._host, metadata, query_params, @@ -4166,21 +5538,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = firestore_admin.ListDatabasesResponse() - pb_resp = firestore_admin.ListDatabasesResponse.pb(resp) + resp = firestore_admin.ListIndexesResponse() + pb_resp = firestore_admin.ListIndexesResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_databases(resp) + resp = self._interceptor.post_list_indexes(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_databases_with_metadata( + resp, _ = self._interceptor.post_list_indexes_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = firestore_admin.ListDatabasesResponse.to_json( + response_payload = firestore_admin.ListIndexesResponse.to_json( response ) except: @@ -4191,21 +5563,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_databases", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_indexes", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListDatabases", + "rpcName": "ListIndexes", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListFields( - _BaseFirestoreAdminRestTransport._BaseListFields, FirestoreAdminRestStub + class _ListUserCreds( + _BaseFirestoreAdminRestTransport._BaseListUserCreds, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ListFields") + return hash("FirestoreAdminRestTransport.ListUserCreds") @staticmethod def _get_response( @@ -4231,18 +5603,18 @@ def _get_response( def __call__( self, - request: firestore_admin.ListFieldsRequest, + request: firestore_admin.ListUserCredsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> firestore_admin.ListFieldsResponse: - r"""Call the list fields method over HTTP. + ) -> firestore_admin.ListUserCredsResponse: + r"""Call the list user creds method over HTTP. Args: - request (~.firestore_admin.ListFieldsRequest): + request (~.firestore_admin.ListUserCredsRequest): The request object. The request for - [FirestoreAdmin.ListFields][google.firestore.admin.v1.FirestoreAdmin.ListFields]. + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -4252,26 +5624,24 @@ def __call__( be of type `bytes`. Returns: - ~.firestore_admin.ListFieldsResponse: + ~.firestore_admin.ListUserCredsResponse: The response for - [FirestoreAdmin.ListFields][google.firestore.admin.v1.FirestoreAdmin.ListFields]. + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseListFields._get_http_options() + _BaseFirestoreAdminRestTransport._BaseListUserCreds._get_http_options() ) - request, metadata = self._interceptor.pre_list_fields(request, metadata) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseListFields._get_transcoded_request( + request, metadata = self._interceptor.pre_list_user_creds(request, metadata) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseListUserCreds._get_transcoded_request( http_options, request ) # Jsonify the query params - query_params = ( - _BaseFirestoreAdminRestTransport._BaseListFields._get_query_params_json( - transcoded_request - ) + query_params = _BaseFirestoreAdminRestTransport._BaseListUserCreds._get_query_params_json( + transcoded_request ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( @@ -4292,17 +5662,17 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListFields", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListUserCreds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListFields", + "rpcName": "ListUserCreds", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ListFields._get_response( + response = FirestoreAdminRestTransport._ListUserCreds._get_response( self._host, metadata, query_params, @@ -4317,21 +5687,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = firestore_admin.ListFieldsResponse() - pb_resp = firestore_admin.ListFieldsResponse.pb(resp) + resp = firestore_admin.ListUserCredsResponse() + pb_resp = firestore_admin.ListUserCredsResponse.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_fields(resp) + resp = self._interceptor.post_list_user_creds(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_fields_with_metadata( + resp, _ = self._interceptor.post_list_user_creds_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = firestore_admin.ListFieldsResponse.to_json( + response_payload = firestore_admin.ListUserCredsResponse.to_json( response ) except: @@ -4342,21 +5712,21 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_fields", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_user_creds", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListFields", + "rpcName": "ListUserCreds", "metadata": http_response["headers"], "httpResponse": http_response, }, ) return resp - class _ListIndexes( - _BaseFirestoreAdminRestTransport._BaseListIndexes, FirestoreAdminRestStub + class _ResetUserPassword( + _BaseFirestoreAdminRestTransport._BaseResetUserPassword, FirestoreAdminRestStub ): def __hash__(self): - return hash("FirestoreAdminRestTransport.ListIndexes") + return hash("FirestoreAdminRestTransport.ResetUserPassword") @staticmethod def _get_response( @@ -4377,23 +5747,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: firestore_admin.ListIndexesRequest, + request: firestore_admin.ResetUserPasswordRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), - ) -> firestore_admin.ListIndexesResponse: - r"""Call the list indexes method over HTTP. + ) -> user_creds.UserCreds: + r"""Call the reset user password method over HTTP. Args: - request (~.firestore_admin.ListIndexesRequest): + request (~.firestore_admin.ResetUserPasswordRequest): The request object. The request for - [FirestoreAdmin.ListIndexes][google.firestore.admin.v1.FirestoreAdmin.ListIndexes]. + [FirestoreAdmin.ResetUserPassword][google.firestore.admin.v1.FirestoreAdmin.ResetUserPassword]. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. @@ -4403,23 +5774,27 @@ def __call__( be of type `bytes`. Returns: - ~.firestore_admin.ListIndexesResponse: - The response for - [FirestoreAdmin.ListIndexes][google.firestore.admin.v1.FirestoreAdmin.ListIndexes]. - + ~.user_creds.UserCreds: + A Cloud Firestore User Creds. """ http_options = ( - _BaseFirestoreAdminRestTransport._BaseListIndexes._get_http_options() + _BaseFirestoreAdminRestTransport._BaseResetUserPassword._get_http_options() ) - request, metadata = self._interceptor.pre_list_indexes(request, metadata) - transcoded_request = _BaseFirestoreAdminRestTransport._BaseListIndexes._get_transcoded_request( + request, metadata = self._interceptor.pre_reset_user_password( + request, metadata + ) + transcoded_request = _BaseFirestoreAdminRestTransport._BaseResetUserPassword._get_transcoded_request( http_options, request ) + body = _BaseFirestoreAdminRestTransport._BaseResetUserPassword._get_request_body_json( + transcoded_request + ) + # Jsonify the query params - query_params = _BaseFirestoreAdminRestTransport._BaseListIndexes._get_query_params_json( + query_params = _BaseFirestoreAdminRestTransport._BaseResetUserPassword._get_query_params_json( transcoded_request ) @@ -4441,23 +5816,24 @@ def __call__( "headers": dict(metadata), } _LOGGER.debug( - f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ListIndexes", + f"Sending request for google.firestore.admin_v1.FirestoreAdminClient.ResetUserPassword", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListIndexes", + "rpcName": "ResetUserPassword", "httpRequest": http_request, "metadata": http_request["headers"], }, ) # Send the request - response = FirestoreAdminRestTransport._ListIndexes._get_response( + response = FirestoreAdminRestTransport._ResetUserPassword._get_response( self._host, metadata, query_params, self._session, timeout, transcoded_request, + body, ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception @@ -4466,23 +5842,21 @@ def __call__( raise core_exceptions.from_http_response(response) # Return the response - resp = firestore_admin.ListIndexesResponse() - pb_resp = firestore_admin.ListIndexesResponse.pb(resp) + resp = user_creds.UserCreds() + pb_resp = user_creds.UserCreds.pb(resp) json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) - resp = self._interceptor.post_list_indexes(resp) + resp = self._interceptor.post_reset_user_password(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] - resp, _ = self._interceptor.post_list_indexes_with_metadata( + resp, _ = self._interceptor.post_reset_user_password_with_metadata( resp, response_metadata ) if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor( logging.DEBUG ): # pragma: NO COVER try: - response_payload = firestore_admin.ListIndexesResponse.to_json( - response - ) + response_payload = user_creds.UserCreds.to_json(response) except: response_payload = None http_response = { @@ -4491,10 +5865,10 @@ def __call__( "status": response.status_code, } _LOGGER.debug( - "Received response for google.firestore.admin_v1.FirestoreAdminClient.list_indexes", + "Received response for google.firestore.admin_v1.FirestoreAdminClient.reset_user_password", extra={ "serviceName": "google.firestore.admin.v1.FirestoreAdmin", - "rpcName": "ListIndexes", + "rpcName": "ResetUserPassword", "metadata": http_response["headers"], "httpResponse": http_response, }, @@ -5155,6 +6529,14 @@ def create_index( # In C++ this would require a dynamic_cast return self._CreateIndex(self._session, self._host, self._interceptor) # type: ignore + @property + def create_user_creds( + self, + ) -> Callable[[firestore_admin.CreateUserCredsRequest], gfa_user_creds.UserCreds]: + # 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._CreateUserCreds(self._session, self._host, self._interceptor) # type: ignore + @property def delete_backup( self, @@ -5187,6 +6569,30 @@ def delete_index( # In C++ this would require a dynamic_cast return self._DeleteIndex(self._session, self._host, self._interceptor) # type: ignore + @property + def delete_user_creds( + self, + ) -> Callable[[firestore_admin.DeleteUserCredsRequest], 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._DeleteUserCreds(self._session, self._host, self._interceptor) # type: ignore + + @property + def disable_user_creds( + self, + ) -> Callable[[firestore_admin.DisableUserCredsRequest], user_creds.UserCreds]: + # 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._DisableUserCreds(self._session, self._host, self._interceptor) # type: ignore + + @property + def enable_user_creds( + self, + ) -> Callable[[firestore_admin.EnableUserCredsRequest], user_creds.UserCreds]: + # 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._EnableUserCreds(self._session, self._host, self._interceptor) # type: ignore + @property def export_documents( self, @@ -5229,6 +6635,14 @@ def get_index(self) -> Callable[[firestore_admin.GetIndexRequest], index.Index]: # In C++ this would require a dynamic_cast return self._GetIndex(self._session, self._host, self._interceptor) # type: ignore + @property + def get_user_creds( + self, + ) -> Callable[[firestore_admin.GetUserCredsRequest], user_creds.UserCreds]: + # 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._GetUserCreds(self._session, self._host, self._interceptor) # type: ignore + @property def import_documents( self, @@ -5288,6 +6702,24 @@ def list_indexes( # In C++ this would require a dynamic_cast return self._ListIndexes(self._session, self._host, self._interceptor) # type: ignore + @property + def list_user_creds( + self, + ) -> Callable[ + [firestore_admin.ListUserCredsRequest], firestore_admin.ListUserCredsResponse + ]: + # 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._ListUserCreds(self._session, self._host, self._interceptor) # type: ignore + + @property + def reset_user_password( + self, + ) -> Callable[[firestore_admin.ResetUserPasswordRequest], user_creds.UserCreds]: + # 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._ResetUserPassword(self._session, self._host, self._interceptor) # type: ignore + @property def restore_database( self, diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest_base.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest_base.py index e1309157e0..19a0c9856f 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest_base.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest_base.py @@ -31,6 +31,8 @@ from google.cloud.firestore_admin_v1.types import firestore_admin from google.cloud.firestore_admin_v1.types import index from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.protobuf import empty_pb2 # type: ignore from google.longrunning import operations_pb2 # type: ignore @@ -327,6 +329,65 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseCreateUserCreds: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "userCredsId": "", + } + + @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/*/databases/*}/userCreds", + "body": "user_creds", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.CreateUserCredsRequest.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( + _BaseFirestoreAdminRestTransport._BaseCreateUserCreds._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseDeleteBackup: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -515,6 +576,167 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseDeleteUserCreds: + 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/*/databases/*/userCreds/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.DeleteUserCredsRequest.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( + _BaseFirestoreAdminRestTransport._BaseDeleteUserCreds._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseDisableUserCreds: + 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/{name=projects/*/databases/*/userCreds/*}:disable", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.DisableUserCredsRequest.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( + _BaseFirestoreAdminRestTransport._BaseDisableUserCreds._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseEnableUserCreds: + 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/{name=projects/*/databases/*/userCreds/*}:enable", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.EnableUserCredsRequest.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( + _BaseFirestoreAdminRestTransport._BaseEnableUserCreds._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseExportDocuments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -807,6 +1029,53 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseGetUserCreds: + 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/*/databases/*/userCreds/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.GetUserCredsRequest.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( + _BaseFirestoreAdminRestTransport._BaseGetUserCreds._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseImportDocuments: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") @@ -1099,6 +1368,110 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseListUserCreds: + 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/*/databases/*}/userCreds", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.ListUserCredsRequest.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( + _BaseFirestoreAdminRestTransport._BaseListUserCreds._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseResetUserPassword: + 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/{name=projects/*/databases/*/userCreds/*}:resetPassword", + "body": "*", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = firestore_admin.ResetUserPasswordRequest.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( + _BaseFirestoreAdminRestTransport._BaseResetUserPassword._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseRestoreDatabase: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") diff --git a/google/cloud/firestore_admin_v1/types/__init__.py b/google/cloud/firestore_admin_v1/types/__init__.py index 0d8d69fa9a..249147d52a 100644 --- a/google/cloud/firestore_admin_v1/types/__init__.py +++ b/google/cloud/firestore_admin_v1/types/__init__.py @@ -29,17 +29,22 @@ CreateDatabaseMetadata, CreateDatabaseRequest, CreateIndexRequest, + CreateUserCredsRequest, DeleteBackupRequest, DeleteBackupScheduleRequest, DeleteDatabaseMetadata, DeleteDatabaseRequest, DeleteIndexRequest, + DeleteUserCredsRequest, + DisableUserCredsRequest, + EnableUserCredsRequest, ExportDocumentsRequest, GetBackupRequest, GetBackupScheduleRequest, GetDatabaseRequest, GetFieldRequest, GetIndexRequest, + GetUserCredsRequest, ImportDocumentsRequest, ListBackupSchedulesRequest, ListBackupSchedulesResponse, @@ -51,6 +56,9 @@ ListFieldsResponse, ListIndexesRequest, ListIndexesResponse, + ListUserCredsRequest, + ListUserCredsResponse, + ResetUserPasswordRequest, RestoreDatabaseRequest, UpdateBackupScheduleRequest, UpdateDatabaseMetadata, @@ -79,6 +87,9 @@ DailyRecurrence, WeeklyRecurrence, ) +from .user_creds import ( + UserCreds, +) __all__ = ( "Backup", @@ -90,17 +101,22 @@ "CreateDatabaseMetadata", "CreateDatabaseRequest", "CreateIndexRequest", + "CreateUserCredsRequest", "DeleteBackupRequest", "DeleteBackupScheduleRequest", "DeleteDatabaseMetadata", "DeleteDatabaseRequest", "DeleteIndexRequest", + "DeleteUserCredsRequest", + "DisableUserCredsRequest", + "EnableUserCredsRequest", "ExportDocumentsRequest", "GetBackupRequest", "GetBackupScheduleRequest", "GetDatabaseRequest", "GetFieldRequest", "GetIndexRequest", + "GetUserCredsRequest", "ImportDocumentsRequest", "ListBackupSchedulesRequest", "ListBackupSchedulesResponse", @@ -112,6 +128,9 @@ "ListFieldsResponse", "ListIndexesRequest", "ListIndexesResponse", + "ListUserCredsRequest", + "ListUserCredsResponse", + "ResetUserPasswordRequest", "RestoreDatabaseRequest", "UpdateBackupScheduleRequest", "UpdateDatabaseMetadata", @@ -131,4 +150,5 @@ "BackupSchedule", "DailyRecurrence", "WeeklyRecurrence", + "UserCreds", ) diff --git a/google/cloud/firestore_admin_v1/types/database.py b/google/cloud/firestore_admin_v1/types/database.py index 778aa84e4f..4f985a6515 100644 --- a/google/cloud/firestore_admin_v1/types/database.py +++ b/google/cloud/firestore_admin_v1/types/database.py @@ -34,6 +34,8 @@ class Database(proto.Message): r"""A Cloud Firestore Database. + .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields + Attributes: name (str): The resource name of the Database. Format: @@ -117,11 +119,31 @@ class Database(proto.Message): source_info (google.cloud.firestore_admin_v1.types.Database.SourceInfo): Output only. Information about the provenance of this database. + free_tier (bool): + Output only. Background: Free tier is the + ability of a Firestore database to use a small + amount of resources every day without being + charged. Once usage exceeds the free tier limit + further usage is charged. + + Whether this database can make use of the free + tier. Only one database per project can be + eligible for the free tier. + + The first (or next) database that is created in + a project without a free tier database will be + marked as eligible for the free tier. Databases + that are created while there is a free tier + database will not be eligible for the free tier. + + This field is a member of `oneof`_ ``_free_tier``. etag (str): This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding. + database_edition (google.cloud.firestore_admin_v1.types.Database.DatabaseEdition): + Immutable. The edition of the database. """ class DatabaseType(proto.Enum): @@ -238,6 +260,23 @@ class DeleteProtectionState(proto.Enum): DELETE_PROTECTION_DISABLED = 1 DELETE_PROTECTION_ENABLED = 2 + class DatabaseEdition(proto.Enum): + r"""The edition of the database. + + Values: + DATABASE_EDITION_UNSPECIFIED (0): + Not used. + STANDARD (1): + Standard edition. + + This is the default setting if not specified. + ENTERPRISE (2): + Enterprise edition. + """ + DATABASE_EDITION_UNSPECIFIED = 0 + STANDARD = 1 + ENTERPRISE = 2 + class CmekConfig(proto.Message): r"""The CMEK (Customer Managed Encryption Key) configuration for a Firestore database. If not present, the database is secured by @@ -485,10 +524,20 @@ class CustomerManagedEncryptionOptions(proto.Message): number=26, message=SourceInfo, ) + free_tier: bool = proto.Field( + proto.BOOL, + number=30, + optional=True, + ) etag: str = proto.Field( proto.STRING, number=99, ) + database_edition: DatabaseEdition = proto.Field( + proto.ENUM, + number=28, + enum=DatabaseEdition, + ) __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/google/cloud/firestore_admin_v1/types/firestore_admin.py b/google/cloud/firestore_admin_v1/types/firestore_admin.py index ca3c4f9729..77d78cb355 100644 --- a/google/cloud/firestore_admin_v1/types/firestore_admin.py +++ b/google/cloud/firestore_admin_v1/types/firestore_admin.py @@ -24,6 +24,7 @@ from google.cloud.firestore_admin_v1.types import field as gfa_field from google.cloud.firestore_admin_v1.types import index as gfa_index from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.protobuf import field_mask_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore @@ -40,6 +41,14 @@ "UpdateDatabaseMetadata", "DeleteDatabaseRequest", "DeleteDatabaseMetadata", + "CreateUserCredsRequest", + "GetUserCredsRequest", + "ListUserCredsRequest", + "ListUserCredsResponse", + "EnableUserCredsRequest", + "DisableUserCredsRequest", + "ResetUserPasswordRequest", + "DeleteUserCredsRequest", "CreateBackupScheduleRequest", "GetBackupScheduleRequest", "UpdateBackupScheduleRequest", @@ -234,6 +243,154 @@ class DeleteDatabaseMetadata(proto.Message): r"""Metadata related to the delete database operation.""" +class CreateUserCredsRequest(proto.Message): + r"""The request for + [FirestoreAdmin.CreateUserCreds][google.firestore.admin.v1.FirestoreAdmin.CreateUserCreds]. + + Attributes: + parent (str): + Required. A parent name of the form + ``projects/{project_id}/databases/{database_id}`` + user_creds (google.cloud.firestore_admin_v1.types.UserCreds): + Required. The user creds to create. + user_creds_id (str): + Required. The ID to use for the user creds, which will + become the final component of the user creds's resource + name. + + This value should be 4-63 characters. Valid characters are + /[a-z][0-9]-/ with first character a letter and the last a + letter or a number. Must not be UUID-like + /[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}/. + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + user_creds: gfa_user_creds.UserCreds = proto.Field( + proto.MESSAGE, + number=2, + message=gfa_user_creds.UserCreds, + ) + user_creds_id: str = proto.Field( + proto.STRING, + number=3, + ) + + +class GetUserCredsRequest(proto.Message): + r"""The request for + [FirestoreAdmin.GetUserCreds][google.firestore.admin.v1.FirestoreAdmin.GetUserCreds]. + + Attributes: + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class ListUserCredsRequest(proto.Message): + r"""The request for + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. + + Attributes: + parent (str): + Required. A parent database name of the form + ``projects/{project_id}/databases/{database_id}`` + """ + + parent: str = proto.Field( + proto.STRING, + number=1, + ) + + +class ListUserCredsResponse(proto.Message): + r"""The response for + [FirestoreAdmin.ListUserCreds][google.firestore.admin.v1.FirestoreAdmin.ListUserCreds]. + + Attributes: + user_creds (MutableSequence[google.cloud.firestore_admin_v1.types.UserCreds]): + The user creds for the database. + """ + + user_creds: MutableSequence[gfa_user_creds.UserCreds] = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=gfa_user_creds.UserCreds, + ) + + +class EnableUserCredsRequest(proto.Message): + r"""The request for + [FirestoreAdmin.EnableUserCreds][google.firestore.admin.v1.FirestoreAdmin.EnableUserCreds]. + + Attributes: + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class DisableUserCredsRequest(proto.Message): + r"""The request for + [FirestoreAdmin.DisableUserCreds][google.firestore.admin.v1.FirestoreAdmin.DisableUserCreds]. + + Attributes: + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class ResetUserPasswordRequest(proto.Message): + r"""The request for + [FirestoreAdmin.ResetUserPassword][google.firestore.admin.v1.FirestoreAdmin.ResetUserPassword]. + + Attributes: + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class DeleteUserCredsRequest(proto.Message): + r"""The request for + [FirestoreAdmin.DeleteUserCreds][google.firestore.admin.v1.FirestoreAdmin.DeleteUserCreds]. + + Attributes: + name (str): + Required. A name of the form + ``projects/{project_id}/databases/{database_id}/userCreds/{user_creds_id}`` + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + class CreateBackupScheduleRequest(proto.Message): r"""The request for [FirestoreAdmin.CreateBackupSchedule][google.firestore.admin.v1.FirestoreAdmin.CreateBackupSchedule]. diff --git a/google/cloud/firestore_admin_v1/types/index.py b/google/cloud/firestore_admin_v1/types/index.py index c317ac38d6..02f9f26470 100644 --- a/google/cloud/firestore_admin_v1/types/index.py +++ b/google/cloud/firestore_admin_v1/types/index.py @@ -69,6 +69,22 @@ class Index(proto.Message): associated field. state (google.cloud.firestore_admin_v1.types.Index.State): Output only. The serving state of the index. + density (google.cloud.firestore_admin_v1.types.Index.Density): + Immutable. The density configuration of the + index. + multikey (bool): + Optional. Whether the index is multikey. By default, the + index is not multikey. For non-multikey indexes, none of the + paths in the index definition reach or traverse an array, + except via an explicit array index. For multikey indexes, at + most one of the paths in the index definition reach or + traverse an array, except via an explicit array index. + Violations will result in errors. + + Note this field only applies to index with + MONGODB_COMPATIBLE_API ApiScope. + shard_count (int): + Optional. The number of shards for the index. """ class QueryScope(proto.Enum): @@ -111,9 +127,12 @@ class ApiScope(proto.Enum): DATASTORE_MODE_API (1): The index can only be used by the Firestore in Datastore Mode query API. + MONGODB_COMPATIBLE_API (2): + The index can only be used by the MONGODB_COMPATIBLE_API. """ ANY_API = 0 DATASTORE_MODE_API = 1 + MONGODB_COMPATIBLE_API = 2 class State(proto.Enum): r"""The state of an index. During index creation, an index will be in @@ -152,6 +171,37 @@ class State(proto.Enum): READY = 2 NEEDS_REPAIR = 3 + class Density(proto.Enum): + r"""The density configuration for the index. + + Values: + DENSITY_UNSPECIFIED (0): + Unspecified. It will use database default + setting. This value is input only. + SPARSE_ALL (1): + In order for an index entry to be added, the document must + contain all fields specified in the index. + + This is the only allowed value for indexes having ApiScope + ``ANY_API`` and ``DATASTORE_MODE_API``. + SPARSE_ANY (2): + In order for an index entry to be added, the + document must contain at least one of the fields + specified in the index. Non-existent fields are + treated as having a NULL value when generating + index entries. + DENSE (3): + An index entry will be added regardless of + whether the document contains any of the fields + specified in the index. Non-existent fields are + treated as having a NULL value when generating + index entries. + """ + DENSITY_UNSPECIFIED = 0 + SPARSE_ALL = 1 + SPARSE_ANY = 2 + DENSE = 3 + class IndexField(proto.Message): r"""A field in an index. The field_path describes which field is indexed, the value_mode describes how the field value is indexed. @@ -298,6 +348,19 @@ class FlatIndex(proto.Message): number=4, enum=State, ) + density: Density = proto.Field( + proto.ENUM, + number=6, + enum=Density, + ) + multikey: bool = proto.Field( + proto.BOOL, + number=7, + ) + shard_count: int = proto.Field( + proto.INT32, + number=8, + ) __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/google/cloud/firestore_admin_v1/types/user_creds.py b/google/cloud/firestore_admin_v1/types/user_creds.py new file mode 100644 index 0000000000..39bd119478 --- /dev/null +++ b/google/cloud/firestore_admin_v1/types/user_creds.py @@ -0,0 +1,124 @@ +# -*- coding: utf-8 -*- +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from __future__ import annotations + +from typing import MutableMapping, MutableSequence + +import proto # type: ignore + +from google.protobuf import timestamp_pb2 # type: ignore + + +__protobuf__ = proto.module( + package="google.firestore.admin.v1", + manifest={ + "UserCreds", + }, +) + + +class UserCreds(proto.Message): + r"""A Cloud Firestore User Creds. + + .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields + + Attributes: + name (str): + Identifier. The resource name of the UserCreds. Format: + ``projects/{project}/databases/{database}/userCreds/{user_creds}`` + create_time (google.protobuf.timestamp_pb2.Timestamp): + Output only. The time the user creds were + created. + update_time (google.protobuf.timestamp_pb2.Timestamp): + Output only. The time the user creds were + last updated. + state (google.cloud.firestore_admin_v1.types.UserCreds.State): + Output only. Whether the user creds are + enabled or disabled. Defaults to ENABLED on + creation. + secure_password (str): + Output only. The plaintext server-generated + password for the user creds. Only populated in + responses for CreateUserCreds and + ResetUserPassword. + resource_identity (google.cloud.firestore_admin_v1.types.UserCreds.ResourceIdentity): + Resource Identity descriptor. + + This field is a member of `oneof`_ ``UserCredsIdentity``. + """ + + class State(proto.Enum): + r"""The state of the user creds (ENABLED or DISABLED). + + Values: + STATE_UNSPECIFIED (0): + The default value. Should not be used. + ENABLED (1): + The user creds are enabled. + DISABLED (2): + The user creds are disabled. + """ + STATE_UNSPECIFIED = 0 + ENABLED = 1 + DISABLED = 2 + + class ResourceIdentity(proto.Message): + r"""Describes a Resource Identity principal. + + Attributes: + principal (str): + Output only. Principal identifier string. + See: + https://cloud.google.com/iam/docs/principal-identifiers + """ + + principal: str = proto.Field( + proto.STRING, + number=1, + ) + + name: str = proto.Field( + proto.STRING, + number=1, + ) + create_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=2, + message=timestamp_pb2.Timestamp, + ) + update_time: timestamp_pb2.Timestamp = proto.Field( + proto.MESSAGE, + number=3, + message=timestamp_pb2.Timestamp, + ) + state: State = proto.Field( + proto.ENUM, + number=4, + enum=State, + ) + secure_password: str = proto.Field( + proto.STRING, + number=5, + ) + resource_identity: ResourceIdentity = proto.Field( + proto.MESSAGE, + number=6, + oneof="UserCredsIdentity", + message=ResourceIdentity, + ) + + +__all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/google/cloud/firestore_v1/services/firestore/transports/grpc.py b/google/cloud/firestore_v1/services/firestore/transports/grpc.py index 35f4bf75fa..c302a73c28 100644 --- a/google/cloud/firestore_v1/services/firestore/transports/grpc.py +++ b/google/cloud/firestore_v1/services/firestore/transports/grpc.py @@ -75,12 +75,11 @@ def intercept_unary_unary(self, continuation, client_call_details, request): f"Sending request for {client_call_details.method}", extra={ "serviceName": "google.firestore.v1.Firestore", - "rpcName": client_call_details.method, + "rpcName": str(client_call_details.method), "request": grpc_request, "metadata": grpc_request["metadata"], }, ) - response = continuation(client_call_details, request) if logging_enabled: # pragma: NO COVER response_metadata = response.trailing_metadata() diff --git a/scripts/fixup_firestore_admin_v1_keywords.py b/scripts/fixup_firestore_admin_v1_keywords.py index dc7a89f764..f4672d2da5 100644 --- a/scripts/fixup_firestore_admin_v1_keywords.py +++ b/scripts/fixup_firestore_admin_v1_keywords.py @@ -49,22 +49,29 @@ class firestore_adminCallTransformer(cst.CSTTransformer): 'create_backup_schedule': ('parent', 'backup_schedule', ), 'create_database': ('parent', 'database', 'database_id', ), 'create_index': ('parent', 'index', ), + 'create_user_creds': ('parent', 'user_creds', 'user_creds_id', ), 'delete_backup': ('name', ), 'delete_backup_schedule': ('name', ), 'delete_database': ('name', 'etag', ), 'delete_index': ('name', ), + 'delete_user_creds': ('name', ), + 'disable_user_creds': ('name', ), + 'enable_user_creds': ('name', ), 'export_documents': ('name', 'collection_ids', 'output_uri_prefix', 'namespace_ids', 'snapshot_time', ), 'get_backup': ('name', ), 'get_backup_schedule': ('name', ), 'get_database': ('name', ), 'get_field': ('name', ), 'get_index': ('name', ), + 'get_user_creds': ('name', ), 'import_documents': ('name', 'collection_ids', 'input_uri_prefix', 'namespace_ids', ), 'list_backups': ('parent', 'filter', ), 'list_backup_schedules': ('parent', ), 'list_databases': ('parent', 'show_deleted', ), 'list_fields': ('parent', 'filter', 'page_size', 'page_token', ), 'list_indexes': ('parent', 'filter', 'page_size', 'page_token', ), + 'list_user_creds': ('parent', ), + 'reset_user_password': ('name', ), 'restore_database': ('parent', 'database_id', 'backup', 'encryption_config', ), 'update_backup_schedule': ('backup_schedule', 'update_mask', ), 'update_database': ('database', 'update_mask', ), diff --git a/tests/unit/gapic/firestore_admin_v1/test_firestore_admin.py b/tests/unit/gapic/firestore_admin_v1/test_firestore_admin.py index 0910287769..421f45a70e 100644 --- a/tests/unit/gapic/firestore_admin_v1/test_firestore_admin.py +++ b/tests/unit/gapic/firestore_admin_v1/test_firestore_admin.py @@ -75,6 +75,8 @@ from google.cloud.firestore_admin_v1.types import index as gfa_index from google.cloud.firestore_admin_v1.types import operation as gfa_operation from google.cloud.firestore_admin_v1.types import schedule +from google.cloud.firestore_admin_v1.types import user_creds +from google.cloud.firestore_admin_v1.types import user_creds as gfa_user_creds from google.cloud.location import locations_pb2 from google.longrunning import operations_pb2 # type: ignore from google.oauth2 import service_account @@ -2022,6 +2024,9 @@ def test_get_index(request_type, transport: str = "grpc"): query_scope=index.Index.QueryScope.COLLECTION, api_scope=index.Index.ApiScope.DATASTORE_MODE_API, state=index.Index.State.CREATING, + density=index.Index.Density.SPARSE_ALL, + multikey=True, + shard_count=1178, ) response = client.get_index(request) @@ -2037,6 +2042,9 @@ def test_get_index(request_type, transport: str = "grpc"): assert response.query_scope == index.Index.QueryScope.COLLECTION assert response.api_scope == index.Index.ApiScope.DATASTORE_MODE_API assert response.state == index.Index.State.CREATING + assert response.density == index.Index.Density.SPARSE_ALL + assert response.multikey is True + assert response.shard_count == 1178 def test_get_index_non_empty_request_with_auto_populated_field(): @@ -2164,6 +2172,9 @@ async def test_get_index_async( query_scope=index.Index.QueryScope.COLLECTION, api_scope=index.Index.ApiScope.DATASTORE_MODE_API, state=index.Index.State.CREATING, + density=index.Index.Density.SPARSE_ALL, + multikey=True, + shard_count=1178, ) ) response = await client.get_index(request) @@ -2180,6 +2191,9 @@ async def test_get_index_async( assert response.query_scope == index.Index.QueryScope.COLLECTION assert response.api_scope == index.Index.ApiScope.DATASTORE_MODE_API assert response.state == index.Index.State.CREATING + assert response.density == index.Index.Density.SPARSE_ALL + assert response.multikey is True + assert response.shard_count == 1178 @pytest.mark.asyncio @@ -5187,7 +5201,9 @@ def test_get_database(request_type, transport: str = "grpc"): key_prefix="key_prefix_value", delete_protection_state=database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED, previous_id="previous_id_value", + free_tier=True, etag="etag_value", + database_edition=database.Database.DatabaseEdition.STANDARD, ) response = client.get_database(request) @@ -5218,7 +5234,9 @@ def test_get_database(request_type, transport: str = "grpc"): == database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED ) assert response.previous_id == "previous_id_value" + assert response.free_tier is True assert response.etag == "etag_value" + assert response.database_edition == database.Database.DatabaseEdition.STANDARD def test_get_database_non_empty_request_with_auto_populated_field(): @@ -5354,7 +5372,9 @@ async def test_get_database_async( key_prefix="key_prefix_value", delete_protection_state=database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED, previous_id="previous_id_value", + free_tier=True, etag="etag_value", + database_edition=database.Database.DatabaseEdition.STANDARD, ) ) response = await client.get_database(request) @@ -5386,7 +5406,9 @@ async def test_get_database_async( == database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED ) assert response.previous_id == "previous_id_value" + assert response.free_tier is True assert response.etag == "etag_value" + assert response.database_edition == database.Database.DatabaseEdition.STANDARD @pytest.mark.asyncio @@ -6521,11 +6543,11 @@ async def test_delete_database_flattened_error_async(): @pytest.mark.parametrize( "request_type", [ - firestore_admin.GetBackupRequest, + firestore_admin.CreateUserCredsRequest, dict, ], ) -def test_get_backup(request_type, transport: str = "grpc"): +def test_create_user_creds(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -6536,31 +6558,31 @@ def test_get_backup(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: # Designate an appropriate return value for the call. - call.return_value = backup.Backup( + call.return_value = gfa_user_creds.UserCreds( name="name_value", - database="database_value", - database_uid="database_uid_value", - state=backup.Backup.State.CREATING, + state=gfa_user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) - response = client.get_backup(request) + response = client.create_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.GetBackupRequest() + request = firestore_admin.CreateUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, backup.Backup) + assert isinstance(response, gfa_user_creds.UserCreds) assert response.name == "name_value" - assert response.database == "database_value" - assert response.database_uid == "database_uid_value" - assert response.state == backup.Backup.State.CREATING + assert response.state == gfa_user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" -def test_get_backup_non_empty_request_with_auto_populated_field(): +def test_create_user_creds_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 = FirestoreAdminClient( @@ -6571,24 +6593,28 @@ def test_get_backup_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.GetBackupRequest( - name="name_value", + request = firestore_admin.CreateUserCredsRequest( + parent="parent_value", + user_creds_id="user_creds_id_value", ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.get_backup(request=request) + client.create_user_creds(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.GetBackupRequest( - name="name_value", + assert args[0] == firestore_admin.CreateUserCredsRequest( + parent="parent_value", + user_creds_id="user_creds_id_value", ) -def test_get_backup_use_cached_wrapped_rpc(): +def test_create_user_creds_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -6602,21 +6628,23 @@ def test_get_backup_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_backup in client._transport._wrapped_methods + assert client._transport.create_user_creds 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_backup] = mock_rpc + client._transport._wrapped_methods[ + client._transport.create_user_creds + ] = mock_rpc request = {} - client.get_backup(request) + client.create_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_backup(request) + client.create_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -6624,7 +6652,9 @@ def test_get_backup_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_get_backup_async_use_cached_wrapped_rpc(transport: str = "grpc_asyncio"): +async def test_create_user_creds_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: @@ -6639,7 +6669,7 @@ async def test_get_backup_async_use_cached_wrapped_rpc(transport: str = "grpc_as # Ensure method has been cached assert ( - client._client._transport.get_backup + client._client._transport.create_user_creds in client._client._transport._wrapped_methods ) @@ -6647,16 +6677,16 @@ async def test_get_backup_async_use_cached_wrapped_rpc(transport: str = "grpc_as mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.get_backup + client._client._transport.create_user_creds ] = mock_rpc request = {} - await client.get_backup(request) + await client.create_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.get_backup(request) + await client.create_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -6664,8 +6694,8 @@ async def test_get_backup_async_use_cached_wrapped_rpc(transport: str = "grpc_as @pytest.mark.asyncio -async def test_get_backup_async( - transport: str = "grpc_asyncio", request_type=firestore_admin.GetBackupRequest +async def test_create_user_creds_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.CreateUserCredsRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -6677,52 +6707,54 @@ async def test_get_backup_async( request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - backup.Backup( + gfa_user_creds.UserCreds( name="name_value", - database="database_value", - database_uid="database_uid_value", - state=backup.Backup.State.CREATING, + state=gfa_user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) ) - response = await client.get_backup(request) + response = await client.create_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.GetBackupRequest() + request = firestore_admin.CreateUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, backup.Backup) + assert isinstance(response, gfa_user_creds.UserCreds) assert response.name == "name_value" - assert response.database == "database_value" - assert response.database_uid == "database_uid_value" - assert response.state == backup.Backup.State.CREATING + assert response.state == gfa_user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.asyncio -async def test_get_backup_async_from_dict(): - await test_get_backup_async(request_type=dict) +async def test_create_user_creds_async_from_dict(): + await test_create_user_creds_async(request_type=dict) -def test_get_backup_field_headers(): +def test_create_user_creds_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.GetBackupRequest() + request = firestore_admin.CreateUserCredsRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: - call.return_value = backup.Backup() - client.get_backup(request) + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: + call.return_value = gfa_user_creds.UserCreds() + client.create_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -6733,26 +6765,30 @@ def test_get_backup_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_get_backup_field_headers_async(): +async def test_create_user_creds_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.GetBackupRequest() + request = firestore_admin.CreateUserCredsRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(backup.Backup()) - await client.get_backup(request) + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gfa_user_creds.UserCreds() + ) + await client.create_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -6763,35 +6799,45 @@ async def test_get_backup_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] -def test_get_backup_flattened(): +def test_create_user_creds_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: # Designate an appropriate return value for the call. - call.return_value = backup.Backup() + call.return_value = gfa_user_creds.UserCreds() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.get_backup( - name="name_value", + client.create_user_creds( + parent="parent_value", + user_creds=gfa_user_creds.UserCreds(name="name_value"), + user_creds_id="user_creds_id_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].user_creds + mock_val = gfa_user_creds.UserCreds(name="name_value") + assert arg == mock_val + arg = args[0].user_creds_id + mock_val = "user_creds_id_value" assert arg == mock_val -def test_get_backup_flattened_error(): +def test_create_user_creds_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -6799,41 +6845,55 @@ def test_get_backup_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_backup( - firestore_admin.GetBackupRequest(), - name="name_value", + client.create_user_creds( + firestore_admin.CreateUserCredsRequest(), + parent="parent_value", + user_creds=gfa_user_creds.UserCreds(name="name_value"), + user_creds_id="user_creds_id_value", ) @pytest.mark.asyncio -async def test_get_backup_flattened_async(): +async def test_create_user_creds_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: # Designate an appropriate return value for the call. - call.return_value = backup.Backup() + call.return_value = gfa_user_creds.UserCreds() - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(backup.Backup()) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gfa_user_creds.UserCreds() + ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.get_backup( - name="name_value", + response = await client.create_user_creds( + parent="parent_value", + user_creds=gfa_user_creds.UserCreds(name="name_value"), + user_creds_id="user_creds_id_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].user_creds + mock_val = gfa_user_creds.UserCreds(name="name_value") + assert arg == mock_val + arg = args[0].user_creds_id + mock_val = "user_creds_id_value" assert arg == mock_val @pytest.mark.asyncio -async def test_get_backup_flattened_error_async(): +async def test_create_user_creds_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -6841,20 +6901,22 @@ async def test_get_backup_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.get_backup( - firestore_admin.GetBackupRequest(), - name="name_value", + await client.create_user_creds( + firestore_admin.CreateUserCredsRequest(), + parent="parent_value", + user_creds=gfa_user_creds.UserCreds(name="name_value"), + user_creds_id="user_creds_id_value", ) @pytest.mark.parametrize( "request_type", [ - firestore_admin.ListBackupsRequest, + firestore_admin.GetUserCredsRequest, dict, ], ) -def test_list_backups(request_type, transport: str = "grpc"): +def test_get_user_creds(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -6865,25 +6927,29 @@ def test_list_backups(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = firestore_admin.ListBackupsResponse( - unreachable=["unreachable_value"], + call.return_value = user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) - response = client.list_backups(request) + response = client.get_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.ListBackupsRequest() + request = firestore_admin.GetUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, firestore_admin.ListBackupsResponse) - assert response.unreachable == ["unreachable_value"] + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" -def test_list_backups_non_empty_request_with_auto_populated_field(): +def test_get_user_creds_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 = FirestoreAdminClient( @@ -6894,26 +6960,24 @@ def test_list_backups_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.ListBackupsRequest( - parent="parent_value", - filter="filter_value", + request = firestore_admin.GetUserCredsRequest( + name="name_value", ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.list_backups(request=request) + client.get_user_creds(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.ListBackupsRequest( - parent="parent_value", - filter="filter_value", + assert args[0] == firestore_admin.GetUserCredsRequest( + name="name_value", ) -def test_list_backups_use_cached_wrapped_rpc(): +def test_get_user_creds_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -6927,21 +6991,21 @@ def test_list_backups_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_backups in client._transport._wrapped_methods + assert client._transport.get_user_creds 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_backups] = mock_rpc + client._transport._wrapped_methods[client._transport.get_user_creds] = mock_rpc request = {} - client.list_backups(request) + client.get_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_backups(request) + client.get_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -6949,7 +7013,7 @@ def test_list_backups_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_list_backups_async_use_cached_wrapped_rpc( +async def test_get_user_creds_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -6966,7 +7030,7 @@ async def test_list_backups_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.list_backups + client._client._transport.get_user_creds in client._client._transport._wrapped_methods ) @@ -6974,16 +7038,16 @@ async def test_list_backups_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.list_backups + client._client._transport.get_user_creds ] = mock_rpc request = {} - await client.list_backups(request) + await client.get_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.list_backups(request) + await client.get_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -6991,8 +7055,8 @@ async def test_list_backups_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_list_backups_async( - transport: str = "grpc_asyncio", request_type=firestore_admin.ListBackupsRequest +async def test_get_user_creds_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.GetUserCredsRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -7004,46 +7068,50 @@ async def test_list_backups_async( request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupsResponse( - unreachable=["unreachable_value"], + user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) ) - response = await client.list_backups(request) + response = await client.get_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.ListBackupsRequest() + request = firestore_admin.GetUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, firestore_admin.ListBackupsResponse) - assert response.unreachable == ["unreachable_value"] + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.asyncio -async def test_list_backups_async_from_dict(): - await test_list_backups_async(request_type=dict) +async def test_get_user_creds_async_from_dict(): + await test_get_user_creds_async(request_type=dict) -def test_list_backups_field_headers(): +def test_get_user_creds_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.ListBackupsRequest() + request = firestore_admin.GetUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: - call.return_value = firestore_admin.ListBackupsResponse() - client.list_backups(request) + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: + call.return_value = user_creds.UserCreds() + client.get_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -7054,28 +7122,28 @@ def test_list_backups_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_list_backups_field_headers_async(): +async def test_get_user_creds_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.ListBackupsRequest() + request = firestore_admin.GetUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupsResponse() + user_creds.UserCreds() ) - await client.list_backups(request) + await client.get_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -7086,35 +7154,35 @@ async def test_list_backups_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] -def test_list_backups_flattened(): +def test_get_user_creds_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = firestore_admin.ListBackupsResponse() + call.return_value = user_creds.UserCreds() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.list_backups( - parent="parent_value", + client.get_user_creds( + name="name_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" + arg = args[0].name + mock_val = "name_value" assert arg == mock_val -def test_list_backups_flattened_error(): +def test_get_user_creds_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -7122,43 +7190,43 @@ def test_list_backups_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_backups( - firestore_admin.ListBackupsRequest(), - parent="parent_value", + client.get_user_creds( + firestore_admin.GetUserCredsRequest(), + name="name_value", ) @pytest.mark.asyncio -async def test_list_backups_flattened_async(): +async def test_get_user_creds_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = firestore_admin.ListBackupsResponse() + call.return_value = user_creds.UserCreds() call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupsResponse() + user_creds.UserCreds() ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.list_backups( - parent="parent_value", + response = await client.get_user_creds( + name="name_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" + arg = args[0].name + mock_val = "name_value" assert arg == mock_val @pytest.mark.asyncio -async def test_list_backups_flattened_error_async(): +async def test_get_user_creds_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -7166,20 +7234,20 @@ async def test_list_backups_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.list_backups( - firestore_admin.ListBackupsRequest(), - parent="parent_value", + await client.get_user_creds( + firestore_admin.GetUserCredsRequest(), + name="name_value", ) @pytest.mark.parametrize( "request_type", [ - firestore_admin.DeleteBackupRequest, + firestore_admin.ListUserCredsRequest, dict, ], ) -def test_delete_backup(request_type, transport: str = "grpc"): +def test_list_user_creds(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -7190,22 +7258,22 @@ def test_delete_backup(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = None - response = client.delete_backup(request) + call.return_value = firestore_admin.ListUserCredsResponse() + response = client.list_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.DeleteBackupRequest() + request = firestore_admin.ListUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, firestore_admin.ListUserCredsResponse) -def test_delete_backup_non_empty_request_with_auto_populated_field(): +def test_list_user_creds_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 = FirestoreAdminClient( @@ -7216,24 +7284,24 @@ def test_delete_backup_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.DeleteBackupRequest( - name="name_value", + request = firestore_admin.ListUserCredsRequest( + parent="parent_value", ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.delete_backup(request=request) + client.list_user_creds(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.DeleteBackupRequest( - name="name_value", + assert args[0] == firestore_admin.ListUserCredsRequest( + parent="parent_value", ) -def test_delete_backup_use_cached_wrapped_rpc(): +def test_list_user_creds_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -7247,21 +7315,21 @@ def test_delete_backup_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_backup in client._transport._wrapped_methods + assert client._transport.list_user_creds 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_backup] = mock_rpc + client._transport._wrapped_methods[client._transport.list_user_creds] = mock_rpc request = {} - client.delete_backup(request) + client.list_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_backup(request) + client.list_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -7269,7 +7337,7 @@ def test_delete_backup_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_delete_backup_async_use_cached_wrapped_rpc( +async def test_list_user_creds_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -7286,7 +7354,7 @@ async def test_delete_backup_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.delete_backup + client._client._transport.list_user_creds in client._client._transport._wrapped_methods ) @@ -7294,16 +7362,16 @@ async def test_delete_backup_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.delete_backup + client._client._transport.list_user_creds ] = mock_rpc request = {} - await client.delete_backup(request) + await client.list_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.delete_backup(request) + await client.list_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -7311,8 +7379,8 @@ async def test_delete_backup_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_delete_backup_async( - transport: str = "grpc_asyncio", request_type=firestore_admin.DeleteBackupRequest +async def test_list_user_creds_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.ListUserCredsRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -7324,41 +7392,43 @@ async def test_delete_backup_async( request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - response = await client.delete_backup(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListUserCredsResponse() + ) + response = await client.list_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.DeleteBackupRequest() + request = firestore_admin.ListUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, firestore_admin.ListUserCredsResponse) @pytest.mark.asyncio -async def test_delete_backup_async_from_dict(): - await test_delete_backup_async(request_type=dict) +async def test_list_user_creds_async_from_dict(): + await test_list_user_creds_async(request_type=dict) -def test_delete_backup_field_headers(): +def test_list_user_creds_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.DeleteBackupRequest() + request = firestore_admin.ListUserCredsRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: - call.return_value = None - client.delete_backup(request) + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: + call.return_value = firestore_admin.ListUserCredsResponse() + client.list_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -7369,26 +7439,28 @@ def test_delete_backup_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_delete_backup_field_headers_async(): +async def test_list_user_creds_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.DeleteBackupRequest() + request = firestore_admin.ListUserCredsRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_backup(request) + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListUserCredsResponse() + ) + await client.list_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -7399,35 +7471,35 @@ async def test_delete_backup_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] -def test_delete_backup_flattened(): +def test_list_user_creds_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = None + call.return_value = firestore_admin.ListUserCredsResponse() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.delete_backup( - name="name_value", + client.list_user_creds( + parent="parent_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" assert arg == mock_val -def test_delete_backup_flattened_error(): +def test_list_user_creds_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -7435,41 +7507,43 @@ def test_delete_backup_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_backup( - firestore_admin.DeleteBackupRequest(), - name="name_value", + client.list_user_creds( + firestore_admin.ListUserCredsRequest(), + parent="parent_value", ) @pytest.mark.asyncio -async def test_delete_backup_flattened_async(): +async def test_list_user_creds_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = None + call.return_value = firestore_admin.ListUserCredsResponse() - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListUserCredsResponse() + ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.delete_backup( - name="name_value", + response = await client.list_user_creds( + parent="parent_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" assert arg == mock_val @pytest.mark.asyncio -async def test_delete_backup_flattened_error_async(): +async def test_list_user_creds_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -7477,20 +7551,20 @@ async def test_delete_backup_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.delete_backup( - firestore_admin.DeleteBackupRequest(), - name="name_value", + await client.list_user_creds( + firestore_admin.ListUserCredsRequest(), + parent="parent_value", ) @pytest.mark.parametrize( "request_type", [ - firestore_admin.RestoreDatabaseRequest, + firestore_admin.EnableUserCredsRequest, dict, ], ) -def test_restore_database(request_type, transport: str = "grpc"): +def test_enable_user_creds(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -7501,22 +7575,31 @@ def test_restore_database(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: # Designate an appropriate return value for the call. - call.return_value = operations_pb2.Operation(name="operations/spam") - response = client.restore_database(request) + call.return_value = user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) + response = client.enable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.RestoreDatabaseRequest() + request = firestore_admin.EnableUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, future.Future) + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" -def test_restore_database_non_empty_request_with_auto_populated_field(): +def test_enable_user_creds_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 = FirestoreAdminClient( @@ -7527,28 +7610,26 @@ def test_restore_database_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.RestoreDatabaseRequest( - parent="parent_value", - database_id="database_id_value", - backup="backup_value", + request = firestore_admin.EnableUserCredsRequest( + name="name_value", ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.restore_database(request=request) + client.enable_user_creds(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.RestoreDatabaseRequest( - parent="parent_value", - database_id="database_id_value", - backup="backup_value", + assert args[0] == firestore_admin.EnableUserCredsRequest( + name="name_value", ) -def test_restore_database_use_cached_wrapped_rpc(): +def test_enable_user_creds_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -7562,7 +7643,7 @@ def test_restore_database_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.restore_database in client._transport._wrapped_methods + assert client._transport.enable_user_creds in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -7570,20 +7651,15 @@ def test_restore_database_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.restore_database + client._transport.enable_user_creds ] = mock_rpc request = {} - client.restore_database(request) + client.enable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods call wrapper_fn to build a cached - # client._transport.operations_client instance on first rpc call. - # Subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.restore_database(request) + client.enable_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -7591,7 +7667,7 @@ def test_restore_database_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_restore_database_async_use_cached_wrapped_rpc( +async def test_enable_user_creds_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -7608,7 +7684,7 @@ async def test_restore_database_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.restore_database + client._client._transport.enable_user_creds in client._client._transport._wrapped_methods ) @@ -7616,21 +7692,16 @@ async def test_restore_database_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.restore_database + client._client._transport.enable_user_creds ] = mock_rpc request = {} - await client.restore_database(request) + await client.enable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods call wrapper_fn to build a cached - # client._transport.operations_client instance on first rpc call. - # Subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - await client.restore_database(request) + await client.enable_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -7638,8 +7709,8 @@ async def test_restore_database_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_restore_database_async( - transport: str = "grpc_asyncio", request_type=firestore_admin.RestoreDatabaseRequest +async def test_enable_user_creds_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.EnableUserCredsRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -7651,43 +7722,54 @@ async def test_restore_database_async( request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) ) - response = await client.restore_database(request) + response = await client.enable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.RestoreDatabaseRequest() + request = firestore_admin.EnableUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, future.Future) + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.asyncio -async def test_restore_database_async_from_dict(): - await test_restore_database_async(request_type=dict) +async def test_enable_user_creds_async_from_dict(): + await test_enable_user_creds_async(request_type=dict) -def test_restore_database_field_headers(): +def test_enable_user_creds_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.RestoreDatabaseRequest() + request = firestore_admin.EnableUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.restore_database), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.restore_database(request) + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: + call.return_value = user_creds.UserCreds() + client.enable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -7698,28 +7780,30 @@ def test_restore_database_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_restore_database_field_headers_async(): +async def test_enable_user_creds_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.RestoreDatabaseRequest() + request = firestore_admin.EnableUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/op") + user_creds.UserCreds() ) - await client.restore_database(request) + await client.enable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -7730,18 +7814,104 @@ async def test_restore_database_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] +def test_enable_user_creds_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = user_creds.UserCreds() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.enable_user_creds( + 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_enable_user_creds_flattened_error(): + client = FirestoreAdminClient( + 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.enable_user_creds( + firestore_admin.EnableUserCredsRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_enable_user_creds_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = user_creds.UserCreds() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + user_creds.UserCreds() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.enable_user_creds( + 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_enable_user_creds_flattened_error_async(): + client = FirestoreAdminAsyncClient( + 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.enable_user_creds( + firestore_admin.EnableUserCredsRequest(), + name="name_value", + ) + + @pytest.mark.parametrize( "request_type", [ - firestore_admin.CreateBackupScheduleRequest, + firestore_admin.DisableUserCredsRequest, dict, ], ) -def test_create_backup_schedule(request_type, transport: str = "grpc"): +def test_disable_user_creds(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -7753,26 +7923,30 @@ def test_create_backup_schedule(request_type, transport: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule( + call.return_value = user_creds.UserCreds( name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) - response = client.create_backup_schedule(request) + response = client.disable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.CreateBackupScheduleRequest() + request = firestore_admin.DisableUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, schedule.BackupSchedule) + assert isinstance(response, user_creds.UserCreds) assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" -def test_create_backup_schedule_non_empty_request_with_auto_populated_field(): +def test_disable_user_creds_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 = FirestoreAdminClient( @@ -7783,26 +7957,26 @@ def test_create_backup_schedule_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.CreateBackupScheduleRequest( - parent="parent_value", + request = firestore_admin.DisableUserCredsRequest( + name="name_value", ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.create_backup_schedule(request=request) + client.disable_user_creds(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.CreateBackupScheduleRequest( - parent="parent_value", + assert args[0] == firestore_admin.DisableUserCredsRequest( + name="name_value", ) -def test_create_backup_schedule_use_cached_wrapped_rpc(): +def test_disable_user_creds_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -7817,8 +7991,7 @@ def test_create_backup_schedule_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.create_backup_schedule - in client._transport._wrapped_methods + client._transport.disable_user_creds in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -7827,15 +8000,15 @@ def test_create_backup_schedule_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.create_backup_schedule + client._transport.disable_user_creds ] = mock_rpc request = {} - client.create_backup_schedule(request) + client.disable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_backup_schedule(request) + client.disable_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -7843,7 +8016,7 @@ def test_create_backup_schedule_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_create_backup_schedule_async_use_cached_wrapped_rpc( +async def test_disable_user_creds_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -7860,7 +8033,7 @@ async def test_create_backup_schedule_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.create_backup_schedule + client._client._transport.disable_user_creds in client._client._transport._wrapped_methods ) @@ -7868,16 +8041,16 @@ async def test_create_backup_schedule_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.create_backup_schedule + client._client._transport.disable_user_creds ] = mock_rpc request = {} - await client.create_backup_schedule(request) + await client.disable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.create_backup_schedule(request) + await client.disable_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -7885,9 +8058,9 @@ async def test_create_backup_schedule_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_create_backup_schedule_async( +async def test_disable_user_creds_async( transport: str = "grpc_asyncio", - request_type=firestore_admin.CreateBackupScheduleRequest, + request_type=firestore_admin.DisableUserCredsRequest, ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -7900,49 +8073,53 @@ async def test_create_backup_schedule_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule( + user_creds.UserCreds( name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) ) - response = await client.create_backup_schedule(request) + response = await client.disable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.CreateBackupScheduleRequest() + request = firestore_admin.DisableUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, schedule.BackupSchedule) + assert isinstance(response, user_creds.UserCreds) assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.asyncio -async def test_create_backup_schedule_async_from_dict(): - await test_create_backup_schedule_async(request_type=dict) +async def test_disable_user_creds_async_from_dict(): + await test_disable_user_creds_async(request_type=dict) -def test_create_backup_schedule_field_headers(): +def test_disable_user_creds_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.CreateBackupScheduleRequest() + request = firestore_admin.DisableUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: - call.return_value = schedule.BackupSchedule() - client.create_backup_schedule(request) + call.return_value = user_creds.UserCreds() + client.disable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -7953,30 +8130,30 @@ def test_create_backup_schedule_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_create_backup_schedule_field_headers_async(): +async def test_disable_user_creds_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.CreateBackupScheduleRequest() + request = firestore_admin.DisableUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule() + user_creds.UserCreds() ) - await client.create_backup_schedule(request) + await client.disable_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -7987,41 +8164,37 @@ async def test_create_backup_schedule_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] -def test_create_backup_schedule_flattened(): +def test_disable_user_creds_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule() + call.return_value = user_creds.UserCreds() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.create_backup_schedule( - parent="parent_value", - backup_schedule=schedule.BackupSchedule(name="name_value"), + client.disable_user_creds( + name="name_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" - assert arg == mock_val - arg = args[0].backup_schedule - mock_val = schedule.BackupSchedule(name="name_value") + arg = args[0].name + mock_val = "name_value" assert arg == mock_val -def test_create_backup_schedule_flattened_error(): +def test_disable_user_creds_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -8029,50 +8202,45 @@ def test_create_backup_schedule_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.create_backup_schedule( - firestore_admin.CreateBackupScheduleRequest(), - parent="parent_value", - backup_schedule=schedule.BackupSchedule(name="name_value"), + client.disable_user_creds( + firestore_admin.DisableUserCredsRequest(), + name="name_value", ) @pytest.mark.asyncio -async def test_create_backup_schedule_flattened_async(): +async def test_disable_user_creds_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" + type(client.transport.disable_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule() + call.return_value = user_creds.UserCreds() call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule() + user_creds.UserCreds() ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.create_backup_schedule( - parent="parent_value", - backup_schedule=schedule.BackupSchedule(name="name_value"), + response = await client.disable_user_creds( + name="name_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" - assert arg == mock_val - arg = args[0].backup_schedule - mock_val = schedule.BackupSchedule(name="name_value") + arg = args[0].name + mock_val = "name_value" assert arg == mock_val @pytest.mark.asyncio -async def test_create_backup_schedule_flattened_error_async(): +async def test_disable_user_creds_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -8080,21 +8248,20 @@ async def test_create_backup_schedule_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.create_backup_schedule( - firestore_admin.CreateBackupScheduleRequest(), - parent="parent_value", - backup_schedule=schedule.BackupSchedule(name="name_value"), + await client.disable_user_creds( + firestore_admin.DisableUserCredsRequest(), + name="name_value", ) @pytest.mark.parametrize( "request_type", [ - firestore_admin.GetBackupScheduleRequest, + firestore_admin.ResetUserPasswordRequest, dict, ], ) -def test_get_backup_schedule(request_type, transport: str = "grpc"): +def test_reset_user_password(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -8106,26 +8273,30 @@ def test_get_backup_schedule(request_type, transport: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule( + call.return_value = user_creds.UserCreds( name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) - response = client.get_backup_schedule(request) + response = client.reset_user_password(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.GetBackupScheduleRequest() + request = firestore_admin.ResetUserPasswordRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, schedule.BackupSchedule) + assert isinstance(response, user_creds.UserCreds) assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" -def test_get_backup_schedule_non_empty_request_with_auto_populated_field(): +def test_reset_user_password_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 = FirestoreAdminClient( @@ -8136,26 +8307,26 @@ def test_get_backup_schedule_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.GetBackupScheduleRequest( + request = firestore_admin.ResetUserPasswordRequest( name="name_value", ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.get_backup_schedule(request=request) + client.reset_user_password(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.GetBackupScheduleRequest( + assert args[0] == firestore_admin.ResetUserPasswordRequest( name="name_value", ) -def test_get_backup_schedule_use_cached_wrapped_rpc(): +def test_reset_user_password_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -8170,7 +8341,7 @@ def test_get_backup_schedule_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.get_backup_schedule in client._transport._wrapped_methods + client._transport.reset_user_password in client._transport._wrapped_methods ) # Replace cached wrapped function with mock @@ -8179,15 +8350,15 @@ def test_get_backup_schedule_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.get_backup_schedule + client._transport.reset_user_password ] = mock_rpc request = {} - client.get_backup_schedule(request) + client.reset_user_password(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_backup_schedule(request) + client.reset_user_password(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -8195,7 +8366,7 @@ def test_get_backup_schedule_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_get_backup_schedule_async_use_cached_wrapped_rpc( +async def test_reset_user_password_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -8212,7 +8383,7 @@ async def test_get_backup_schedule_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.get_backup_schedule + client._client._transport.reset_user_password in client._client._transport._wrapped_methods ) @@ -8220,16 +8391,16 @@ async def test_get_backup_schedule_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.get_backup_schedule + client._client._transport.reset_user_password ] = mock_rpc request = {} - await client.get_backup_schedule(request) + await client.reset_user_password(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.get_backup_schedule(request) + await client.reset_user_password(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -8237,9 +8408,9 @@ async def test_get_backup_schedule_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_get_backup_schedule_async( +async def test_reset_user_password_async( transport: str = "grpc_asyncio", - request_type=firestore_admin.GetBackupScheduleRequest, + request_type=firestore_admin.ResetUserPasswordRequest, ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -8252,49 +8423,53 @@ async def test_get_backup_schedule_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule( + user_creds.UserCreds( name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) ) - response = await client.get_backup_schedule(request) + response = await client.reset_user_password(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.GetBackupScheduleRequest() + request = firestore_admin.ResetUserPasswordRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, schedule.BackupSchedule) + assert isinstance(response, user_creds.UserCreds) assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.asyncio -async def test_get_backup_schedule_async_from_dict(): - await test_get_backup_schedule_async(request_type=dict) +async def test_reset_user_password_async_from_dict(): + await test_reset_user_password_async(request_type=dict) -def test_get_backup_schedule_field_headers(): +def test_reset_user_password_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.GetBackupScheduleRequest() + request = firestore_admin.ResetUserPasswordRequest() request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: - call.return_value = schedule.BackupSchedule() - client.get_backup_schedule(request) + call.return_value = user_creds.UserCreds() + client.reset_user_password(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -8310,25 +8485,25 @@ def test_get_backup_schedule_field_headers(): @pytest.mark.asyncio -async def test_get_backup_schedule_field_headers_async(): +async def test_reset_user_password_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.GetBackupScheduleRequest() + request = firestore_admin.ResetUserPasswordRequest() request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule() + user_creds.UserCreds() ) - await client.get_backup_schedule(request) + await client.reset_user_password(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -8343,20 +8518,20 @@ async def test_get_backup_schedule_field_headers_async(): ) in kw["metadata"] -def test_get_backup_schedule_flattened(): +def test_reset_user_password_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule() + call.return_value = user_creds.UserCreds() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.get_backup_schedule( + client.reset_user_password( name="name_value", ) @@ -8369,7 +8544,7 @@ def test_get_backup_schedule_flattened(): assert arg == mock_val -def test_get_backup_schedule_flattened_error(): +def test_reset_user_password_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -8377,31 +8552,31 @@ def test_get_backup_schedule_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.get_backup_schedule( - firestore_admin.GetBackupScheduleRequest(), + client.reset_user_password( + firestore_admin.ResetUserPasswordRequest(), name="name_value", ) @pytest.mark.asyncio -async def test_get_backup_schedule_flattened_async(): +async def test_reset_user_password_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" + type(client.transport.reset_user_password), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule() + call.return_value = user_creds.UserCreds() call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule() + user_creds.UserCreds() ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.get_backup_schedule( + response = await client.reset_user_password( name="name_value", ) @@ -8415,7 +8590,7 @@ async def test_get_backup_schedule_flattened_async(): @pytest.mark.asyncio -async def test_get_backup_schedule_flattened_error_async(): +async def test_reset_user_password_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -8423,8 +8598,8 @@ async def test_get_backup_schedule_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.get_backup_schedule( - firestore_admin.GetBackupScheduleRequest(), + await client.reset_user_password( + firestore_admin.ResetUserPasswordRequest(), name="name_value", ) @@ -8432,11 +8607,11 @@ async def test_get_backup_schedule_flattened_error_async(): @pytest.mark.parametrize( "request_type", [ - firestore_admin.ListBackupSchedulesRequest, + firestore_admin.DeleteUserCredsRequest, dict, ], ) -def test_list_backup_schedules(request_type, transport: str = "grpc"): +def test_delete_user_creds(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -8448,23 +8623,23 @@ def test_list_backup_schedules(request_type, transport: str = "grpc"): # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = firestore_admin.ListBackupSchedulesResponse() - response = client.list_backup_schedules(request) + call.return_value = None + response = client.delete_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.ListBackupSchedulesRequest() + request = firestore_admin.DeleteUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, firestore_admin.ListBackupSchedulesResponse) + assert response is None -def test_list_backup_schedules_non_empty_request_with_auto_populated_field(): +def test_delete_user_creds_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 = FirestoreAdminClient( @@ -8475,26 +8650,26 @@ def test_list_backup_schedules_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.ListBackupSchedulesRequest( - parent="parent_value", + request = firestore_admin.DeleteUserCredsRequest( + name="name_value", ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.list_backup_schedules(request=request) + client.delete_user_creds(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.ListBackupSchedulesRequest( - parent="parent_value", + assert args[0] == firestore_admin.DeleteUserCredsRequest( + name="name_value", ) -def test_list_backup_schedules_use_cached_wrapped_rpc(): +def test_delete_user_creds_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -8508,10 +8683,7 @@ def test_list_backup_schedules_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_backup_schedules - in client._transport._wrapped_methods - ) + assert client._transport.delete_user_creds in client._transport._wrapped_methods # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -8519,15 +8691,15 @@ def test_list_backup_schedules_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.list_backup_schedules + client._transport.delete_user_creds ] = mock_rpc request = {} - client.list_backup_schedules(request) + client.delete_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_backup_schedules(request) + client.delete_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -8535,7 +8707,7 @@ def test_list_backup_schedules_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_list_backup_schedules_async_use_cached_wrapped_rpc( +async def test_delete_user_creds_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -8552,7 +8724,7 @@ async def test_list_backup_schedules_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.list_backup_schedules + client._client._transport.delete_user_creds in client._client._transport._wrapped_methods ) @@ -8560,16 +8732,16 @@ async def test_list_backup_schedules_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.list_backup_schedules + client._client._transport.delete_user_creds ] = mock_rpc request = {} - await client.list_backup_schedules(request) + await client.delete_user_creds(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.list_backup_schedules(request) + await client.delete_user_creds(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -8577,9 +8749,8 @@ async def test_list_backup_schedules_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_list_backup_schedules_async( - transport: str = "grpc_asyncio", - request_type=firestore_admin.ListBackupSchedulesRequest, +async def test_delete_user_creds_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.DeleteUserCredsRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -8592,46 +8763,44 @@ async def test_list_backup_schedules_async( # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupSchedulesResponse() - ) - response = await client.list_backup_schedules(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.ListBackupSchedulesRequest() + request = firestore_admin.DeleteUserCredsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, firestore_admin.ListBackupSchedulesResponse) + assert response is None @pytest.mark.asyncio -async def test_list_backup_schedules_async_from_dict(): - await test_list_backup_schedules_async(request_type=dict) +async def test_delete_user_creds_async_from_dict(): + await test_delete_user_creds_async(request_type=dict) -def test_list_backup_schedules_field_headers(): +def test_delete_user_creds_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.ListBackupSchedulesRequest() + request = firestore_admin.DeleteUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: - call.return_value = firestore_admin.ListBackupSchedulesResponse() - client.list_backup_schedules(request) + call.return_value = None + client.delete_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -8642,30 +8811,28 @@ def test_list_backup_schedules_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_list_backup_schedules_field_headers_async(): +async def test_delete_user_creds_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.ListBackupSchedulesRequest() + request = firestore_admin.DeleteUserCredsRequest() - request.parent = "parent_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupSchedulesResponse() - ) - await client.list_backup_schedules(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_user_creds(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -8676,37 +8843,37 @@ async def test_list_backup_schedules_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "parent=parent_value", + "name=name_value", ) in kw["metadata"] -def test_list_backup_schedules_flattened(): +def test_delete_user_creds_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = firestore_admin.ListBackupSchedulesResponse() + call.return_value = None # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.list_backup_schedules( - parent="parent_value", + client.delete_user_creds( + name="name_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" + arg = args[0].name + mock_val = "name_value" assert arg == mock_val -def test_list_backup_schedules_flattened_error(): +def test_delete_user_creds_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -8714,45 +8881,43 @@ def test_list_backup_schedules_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_backup_schedules( - firestore_admin.ListBackupSchedulesRequest(), - parent="parent_value", + client.delete_user_creds( + firestore_admin.DeleteUserCredsRequest(), + name="name_value", ) @pytest.mark.asyncio -async def test_list_backup_schedules_flattened_async(): +async def test_delete_user_creds_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" + type(client.transport.delete_user_creds), "__call__" ) as call: # Designate an appropriate return value for the call. - call.return_value = firestore_admin.ListBackupSchedulesResponse() + call.return_value = None - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupSchedulesResponse() - ) + 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.list_backup_schedules( - parent="parent_value", + response = await client.delete_user_creds( + name="name_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].parent - mock_val = "parent_value" + arg = args[0].name + mock_val = "name_value" assert arg == mock_val @pytest.mark.asyncio -async def test_list_backup_schedules_flattened_error_async(): +async def test_delete_user_creds_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -8760,20 +8925,20 @@ async def test_list_backup_schedules_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.list_backup_schedules( - firestore_admin.ListBackupSchedulesRequest(), - parent="parent_value", + await client.delete_user_creds( + firestore_admin.DeleteUserCredsRequest(), + name="name_value", ) @pytest.mark.parametrize( "request_type", [ - firestore_admin.UpdateBackupScheduleRequest, + firestore_admin.GetBackupRequest, dict, ], ) -def test_update_backup_schedule(request_type, transport: str = "grpc"): +def test_get_backup(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -8784,27 +8949,31 @@ def test_update_backup_schedule(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule( + call.return_value = backup.Backup( name="name_value", + database="database_value", + database_uid="database_uid_value", + state=backup.Backup.State.CREATING, ) - response = client.update_backup_schedule(request) + response = client.get_backup(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.UpdateBackupScheduleRequest() + request = firestore_admin.GetBackupRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, schedule.BackupSchedule) + assert isinstance(response, backup.Backup) assert response.name == "name_value" + assert response.database == "database_value" + assert response.database_uid == "database_uid_value" + assert response.state == backup.Backup.State.CREATING -def test_update_backup_schedule_non_empty_request_with_auto_populated_field(): +def test_get_backup_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 = FirestoreAdminClient( @@ -8815,22 +8984,24 @@ def test_update_backup_schedule_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.UpdateBackupScheduleRequest() + request = firestore_admin.GetBackupRequest( + name="name_value", + ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.update_backup_schedule(request=request) + client.get_backup(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.UpdateBackupScheduleRequest() + assert args[0] == firestore_admin.GetBackupRequest( + name="name_value", + ) -def test_update_backup_schedule_use_cached_wrapped_rpc(): +def test_get_backup_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -8844,26 +9015,21 @@ def test_update_backup_schedule_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_backup_schedule - in client._transport._wrapped_methods - ) + assert client._transport.get_backup 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_backup_schedule - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_backup] = mock_rpc request = {} - client.update_backup_schedule(request) + client.get_backup(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_backup_schedule(request) + client.get_backup(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -8871,9 +9037,7 @@ def test_update_backup_schedule_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_update_backup_schedule_async_use_cached_wrapped_rpc( - transport: str = "grpc_asyncio", -): +async def test_get_backup_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: @@ -8888,7 +9052,7 @@ async def test_update_backup_schedule_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.update_backup_schedule + client._client._transport.get_backup in client._client._transport._wrapped_methods ) @@ -8896,16 +9060,16 @@ async def test_update_backup_schedule_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.update_backup_schedule + client._client._transport.get_backup ] = mock_rpc request = {} - await client.update_backup_schedule(request) + await client.get_backup(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.update_backup_schedule(request) + await client.get_backup(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -8913,9 +9077,8 @@ async def test_update_backup_schedule_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_update_backup_schedule_async( - transport: str = "grpc_asyncio", - request_type=firestore_admin.UpdateBackupScheduleRequest, +async def test_get_backup_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.GetBackupRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -8927,50 +9090,52 @@ async def test_update_backup_schedule_async( request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule( + backup.Backup( name="name_value", + database="database_value", + database_uid="database_uid_value", + state=backup.Backup.State.CREATING, ) ) - response = await client.update_backup_schedule(request) + response = await client.get_backup(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.UpdateBackupScheduleRequest() + request = firestore_admin.GetBackupRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, schedule.BackupSchedule) + assert isinstance(response, backup.Backup) assert response.name == "name_value" + assert response.database == "database_value" + assert response.database_uid == "database_uid_value" + assert response.state == backup.Backup.State.CREATING @pytest.mark.asyncio -async def test_update_backup_schedule_async_from_dict(): - await test_update_backup_schedule_async(request_type=dict) +async def test_get_backup_async_from_dict(): + await test_get_backup_async(request_type=dict) -def test_update_backup_schedule_field_headers(): +def test_get_backup_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.UpdateBackupScheduleRequest() + request = firestore_admin.GetBackupRequest() - request.backup_schedule.name = "name_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: - call.return_value = schedule.BackupSchedule() - client.update_backup_schedule(request) + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + call.return_value = backup.Backup() + client.get_backup(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -8981,30 +9146,26 @@ def test_update_backup_schedule_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "backup_schedule.name=name_value", + "name=name_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_update_backup_schedule_field_headers_async(): +async def test_get_backup_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.UpdateBackupScheduleRequest() + request = firestore_admin.GetBackupRequest() - request.backup_schedule.name = "name_value" + request.name = "name_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule() - ) - await client.update_backup_schedule(request) + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(backup.Backup()) + await client.get_backup(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -9015,41 +9176,35 @@ async def test_update_backup_schedule_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "backup_schedule.name=name_value", + "name=name_value", ) in kw["metadata"] -def test_update_backup_schedule_flattened(): +def test_get_backup_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule() + call.return_value = backup.Backup() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.update_backup_schedule( - backup_schedule=schedule.BackupSchedule(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_backup( + 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].backup_schedule - mock_val = schedule.BackupSchedule(name="name_value") - assert arg == mock_val - arg = args[0].update_mask - mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + arg = args[0].name + mock_val = "name_value" assert arg == mock_val -def test_update_backup_schedule_flattened_error(): +def test_get_backup_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -9057,50 +9212,41 @@ def test_update_backup_schedule_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.update_backup_schedule( - firestore_admin.UpdateBackupScheduleRequest(), - backup_schedule=schedule.BackupSchedule(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_backup( + firestore_admin.GetBackupRequest(), + name="name_value", ) @pytest.mark.asyncio -async def test_update_backup_schedule_flattened_async(): +async def test_get_backup_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = schedule.BackupSchedule() + call.return_value = backup.Backup() - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule() - ) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(backup.Backup()) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.update_backup_schedule( - backup_schedule=schedule.BackupSchedule(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + response = await client.get_backup( + 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].backup_schedule - mock_val = schedule.BackupSchedule(name="name_value") - assert arg == mock_val - arg = args[0].update_mask - mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + arg = args[0].name + mock_val = "name_value" assert arg == mock_val @pytest.mark.asyncio -async def test_update_backup_schedule_flattened_error_async(): +async def test_get_backup_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -9108,21 +9254,20 @@ async def test_update_backup_schedule_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.update_backup_schedule( - firestore_admin.UpdateBackupScheduleRequest(), - backup_schedule=schedule.BackupSchedule(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + await client.get_backup( + firestore_admin.GetBackupRequest(), + name="name_value", ) @pytest.mark.parametrize( "request_type", [ - firestore_admin.DeleteBackupScheduleRequest, + firestore_admin.ListBackupsRequest, dict, ], ) -def test_delete_backup_schedule(request_type, transport: str = "grpc"): +def test_list_backups(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -9133,24 +9278,25 @@ def test_delete_backup_schedule(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = None - response = client.delete_backup_schedule(request) + call.return_value = firestore_admin.ListBackupsResponse( + unreachable=["unreachable_value"], + ) + response = client.list_backups(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = firestore_admin.DeleteBackupScheduleRequest() + request = firestore_admin.ListBackupsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, firestore_admin.ListBackupsResponse) + assert response.unreachable == ["unreachable_value"] -def test_delete_backup_schedule_non_empty_request_with_auto_populated_field(): +def test_list_backups_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 = FirestoreAdminClient( @@ -9161,26 +9307,26 @@ def test_delete_backup_schedule_non_empty_request_with_auto_populated_field(): # 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 = firestore_admin.DeleteBackupScheduleRequest( - name="name_value", + request = firestore_admin.ListBackupsRequest( + parent="parent_value", + filter="filter_value", ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.delete_backup_schedule(request=request) + client.list_backups(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == firestore_admin.DeleteBackupScheduleRequest( - name="name_value", + assert args[0] == firestore_admin.ListBackupsRequest( + parent="parent_value", + filter="filter_value", ) -def test_delete_backup_schedule_use_cached_wrapped_rpc(): +def test_list_backups_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -9194,26 +9340,21 @@ def test_delete_backup_schedule_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_backup_schedule - in client._transport._wrapped_methods - ) + assert client._transport.list_backups 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_backup_schedule - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_backups] = mock_rpc request = {} - client.delete_backup_schedule(request) + client.list_backups(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_backup_schedule(request) + client.list_backups(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -9221,7 +9362,7 @@ def test_delete_backup_schedule_use_cached_wrapped_rpc(): @pytest.mark.asyncio -async def test_delete_backup_schedule_async_use_cached_wrapped_rpc( +async def test_list_backups_async_use_cached_wrapped_rpc( transport: str = "grpc_asyncio", ): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, @@ -9238,7 +9379,7 @@ async def test_delete_backup_schedule_async_use_cached_wrapped_rpc( # Ensure method has been cached assert ( - client._client._transport.delete_backup_schedule + client._client._transport.list_backups in client._client._transport._wrapped_methods ) @@ -9246,16 +9387,16 @@ async def test_delete_backup_schedule_async_use_cached_wrapped_rpc( mock_rpc = mock.AsyncMock() mock_rpc.return_value = mock.Mock() client._client._transport._wrapped_methods[ - client._client._transport.delete_backup_schedule + client._client._transport.list_backups ] = mock_rpc request = {} - await client.delete_backup_schedule(request) + await client.list_backups(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - await client.delete_backup_schedule(request) + await client.list_backups(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 @@ -9263,9 +9404,8 @@ async def test_delete_backup_schedule_async_use_cached_wrapped_rpc( @pytest.mark.asyncio -async def test_delete_backup_schedule_async( - transport: str = "grpc_asyncio", - request_type=firestore_admin.DeleteBackupScheduleRequest, +async def test_list_backups_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.ListBackupsRequest ): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), @@ -9277,45 +9417,46 @@ async def test_delete_backup_schedule_async( request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - response = await client.delete_backup_schedule(request) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupsResponse( + unreachable=["unreachable_value"], + ) + ) + response = await client.list_backups(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - request = firestore_admin.DeleteBackupScheduleRequest() + request = firestore_admin.ListBackupsRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert response is None + assert isinstance(response, firestore_admin.ListBackupsResponse) + assert response.unreachable == ["unreachable_value"] @pytest.mark.asyncio -async def test_delete_backup_schedule_async_from_dict(): - await test_delete_backup_schedule_async(request_type=dict) +async def test_list_backups_async_from_dict(): + await test_list_backups_async(request_type=dict) -def test_delete_backup_schedule_field_headers(): +def test_list_backups_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.DeleteBackupScheduleRequest() + request = firestore_admin.ListBackupsRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: - call.return_value = None - client.delete_backup_schedule(request) + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + call.return_value = firestore_admin.ListBackupsResponse() + client.list_backups(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 @@ -9326,28 +9467,28 @@ def test_delete_backup_schedule_field_headers(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] @pytest.mark.asyncio -async def test_delete_backup_schedule_field_headers_async(): +async def test_list_backups_field_headers_async(): client = FirestoreAdminAsyncClient( 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 = firestore_admin.DeleteBackupScheduleRequest() + request = firestore_admin.ListBackupsRequest() - request.name = "name_value" + request.parent = "parent_value" # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_backup_schedule(request) + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupsResponse() + ) + await client.list_backups(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) @@ -9358,37 +9499,35 @@ async def test_delete_backup_schedule_field_headers_async(): _, _, kw = call.mock_calls[0] assert ( "x-goog-request-params", - "name=name_value", + "parent=parent_value", ) in kw["metadata"] -def test_delete_backup_schedule_flattened(): +def test_list_backups_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = None + call.return_value = firestore_admin.ListBackupsResponse() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.delete_backup_schedule( - name="name_value", + client.list_backups( + parent="parent_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" assert arg == mock_val -def test_delete_backup_schedule_flattened_error(): +def test_list_backups_flattened_error(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), ) @@ -9396,43 +9535,43 @@ def test_delete_backup_schedule_flattened_error(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.delete_backup_schedule( - firestore_admin.DeleteBackupScheduleRequest(), - name="name_value", + client.list_backups( + firestore_admin.ListBackupsRequest(), + parent="parent_value", ) @pytest.mark.asyncio -async def test_delete_backup_schedule_flattened_async(): +async def test_list_backups_flattened_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = None + call.return_value = firestore_admin.ListBackupsResponse() - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupsResponse() + ) # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - response = await client.delete_backup_schedule( - name="name_value", + response = await client.list_backups( + parent="parent_value", ) # Establish that the underlying call was made with the expected # request object values. assert len(call.mock_calls) _, args, _ = call.mock_calls[0] - arg = args[0].name - mock_val = "name_value" + arg = args[0].parent + mock_val = "parent_value" assert arg == mock_val @pytest.mark.asyncio -async def test_delete_backup_schedule_flattened_error_async(): +async def test_list_backups_flattened_error_async(): client = FirestoreAdminAsyncClient( credentials=async_anonymous_credentials(), ) @@ -9440,19 +9579,80 @@ async def test_delete_backup_schedule_flattened_error_async(): # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - await client.delete_backup_schedule( - firestore_admin.DeleteBackupScheduleRequest(), + await client.list_backups( + firestore_admin.ListBackupsRequest(), + parent="parent_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.DeleteBackupRequest, + dict, + ], +) +def test_delete_backup(request_type, transport: str = "grpc"): + client = FirestoreAdminClient( + 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_backup), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_backup(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.DeleteBackupRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_backup_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 = FirestoreAdminClient( + 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 = firestore_admin.DeleteBackupRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_backup(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.DeleteBackupRequest( name="name_value", ) -def test_create_index_rest_use_cached_wrapped_rpc(): +def test_delete_backup_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -9460,189 +9660,314 @@ def test_create_index_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_index in client._transport._wrapped_methods + assert client._transport.delete_backup 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_index] = mock_rpc - + client._transport._wrapped_methods[client._transport.delete_backup] = mock_rpc request = {} - client.create_index(request) + client.delete_backup(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.create_index(request) + client.delete_backup(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_index_rest_required_fields( - request_type=firestore_admin.CreateIndexRequest, +@pytest.mark.asyncio +async def test_delete_backup_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.FirestoreAdminRestTransport + # Clients should use _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 = FirestoreAdminAsyncClient( + 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.delete_backup + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).create_index._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_backup + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.delete_backup(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_index._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + await client.delete_backup(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 = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + +@pytest.mark.asyncio +async def test_delete_backup_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.DeleteBackupRequest +): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "post", - "query_params": pb_request, - } - transcode_result["body"] = pb_request - transcode.return_value = transcode_result + # 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 - json_return_value = json_format.MessageToJson(return_value) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_backup(request) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = firestore_admin.DeleteBackupRequest() + assert args[0] == request - response = client.create_index(request) + # Establish that the response is the type that we expect. + assert response is None - 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_backup_async_from_dict(): + await test_delete_backup_async(request_type=dict) -def test_create_index_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials +def test_delete_backup_field_headers(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), ) - unset_fields = transport.create_index._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "index", - ) - ) + # 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 = firestore_admin.DeleteBackupRequest() + + request.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + call.return_value = None + client.delete_backup(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_backup_field_headers_async(): + client = FirestoreAdminAsyncClient( + 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 = firestore_admin.DeleteBackupRequest() + + request.name = "name_value" -def test_create_index_rest_flattened(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_backup(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_delete_backup_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__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_backup( + name="name_value", + ) - # get arguments that satisfy an http rule for this method - sample_request = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", - index=gfa_index.Index(name="name_value"), + +def test_delete_backup_flattened_error(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_backup( + firestore_admin.DeleteBackupRequest(), + name="name_value", ) - mock_args.update(sample_request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.create_index(**mock_args) +@pytest.mark.asyncio +async def test_delete_backup_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__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_backup( + 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/*/databases/*/collectionGroups/*}/indexes" - % client.transport._host, - args[1], + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_delete_backup_flattened_error_async(): + client = FirestoreAdminAsyncClient( + 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_backup( + firestore_admin.DeleteBackupRequest(), + name="name_value", ) -def test_create_index_rest_flattened_error(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.RestoreDatabaseRequest, + dict, + ], +) +def test_restore_database(request_type, transport: str = "grpc"): client = FirestoreAdminClient( 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_index( - firestore_admin.CreateIndexRequest(), + # 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.restore_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.restore_database(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.RestoreDatabaseRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_restore_database_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 = FirestoreAdminClient( + 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 = firestore_admin.RestoreDatabaseRequest( + parent="parent_value", + database_id="database_id_value", + backup="backup_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.restore_database(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.RestoreDatabaseRequest( parent="parent_value", - index=gfa_index.Index(name="name_value"), + database_id="database_id_value", + backup="backup_value", ) -def test_list_indexes_rest_use_cached_wrapped_rpc(): +def test_restore_database_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -9650,261 +9975,253 @@ def test_list_indexes_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_indexes in client._transport._wrapped_methods + assert client._transport.restore_database 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_indexes] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.restore_database + ] = mock_rpc request = {} - client.list_indexes(request) + client.restore_database(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_indexes(request) + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.restore_database(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_indexes_rest_required_fields( - request_type=firestore_admin.ListIndexesRequest, +@pytest.mark.asyncio +async def test_restore_database_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.FirestoreAdminRestTransport - - 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) - ) + # Clients should use _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 = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - # verify fields with default values are dropped + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_indexes._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Ensure method has been cached + assert ( + client._client._transport.restore_database + in client._client._transport._wrapped_methods + ) - # verify required fields with default values are now present + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.restore_database + ] = mock_rpc - jsonified_request["parent"] = "parent_value" + request = {} + await client.restore_database(request) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_indexes._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "filter", - "page_size", - "page_token", - ) - ) - jsonified_request.update(unset_fields) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + # Operation methods call wrapper_fn to build a cached + # client._transport.operations_client instance on first rpc call. + # Subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + await client.restore_database(request) - # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListIndexesResponse() - # 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 = firestore_admin.ListIndexesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_restore_database_async( + transport: str = "grpc_asyncio", request_type=firestore_admin.RestoreDatabaseRequest +): + client = FirestoreAdminAsyncClient( + 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_indexes(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.restore_database(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 = firestore_admin.RestoreDatabaseRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) -def test_list_indexes_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.list_indexes._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) +@pytest.mark.asyncio +async def test_restore_database_async_from_dict(): + await test_restore_database_async(request_type=dict) -def test_list_indexes_rest_flattened(): +def test_restore_database_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.ListIndexesResponse() + # 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 = firestore_admin.RestoreDatabaseRequest() - # get arguments that satisfy an http rule for this method - sample_request = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } + request.parent = "parent_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.restore_database), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.restore_database(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 = firestore_admin.ListIndexesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_indexes(**mock_args) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] - # 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/*/databases/*/collectionGroups/*}/indexes" - % client.transport._host, - args[1], + +@pytest.mark.asyncio +async def test_restore_database_field_headers_async(): + client = FirestoreAdminAsyncClient( + 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 = firestore_admin.RestoreDatabaseRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") ) + await client.restore_database(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_indexes_rest_flattened_error(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.CreateBackupScheduleRequest, + dict, + ], +) +def test_create_backup_schedule(request_type, transport: str = "grpc"): client = FirestoreAdminClient( 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_indexes( - firestore_admin.ListIndexesRequest(), - parent="parent_value", + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule( + name="name_value", ) + response = client.create_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.CreateBackupScheduleRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, schedule.BackupSchedule) + assert response.name == "name_value" -def test_list_indexes_rest_pager(transport: str = "rest"): +def test_create_backup_schedule_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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="grpc", ) - # 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 = ( - firestore_admin.ListIndexesResponse( - indexes=[ - index.Index(), - index.Index(), - index.Index(), - ], - next_page_token="abc", - ), - firestore_admin.ListIndexesResponse( - indexes=[], - next_page_token="def", - ), - firestore_admin.ListIndexesResponse( - indexes=[ - index.Index(), - ], - next_page_token="ghi", - ), - firestore_admin.ListIndexesResponse( - indexes=[ - index.Index(), - index.Index(), - ], - ), - ) - # Two responses for two calls - response = response + response + # 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 = firestore_admin.CreateBackupScheduleRequest( + parent="parent_value", + ) - # Wrap the values into proper Response objs - response = tuple( - firestore_admin.ListIndexesResponse.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.create_backup_schedule), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.create_backup_schedule(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.CreateBackupScheduleRequest( + parent="parent_value", ) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - - sample_request = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } - - pager = client.list_indexes(request=sample_request) - - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, index.Index) for i in results) - - pages = list(client.list_indexes(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token -def test_get_index_rest_use_cached_wrapped_rpc(): +def test_create_backup_schedule_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -9912,177 +10229,352 @@ def test_get_index_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_index in client._transport._wrapped_methods + assert ( + client._transport.create_backup_schedule + 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_index] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.create_backup_schedule + ] = mock_rpc request = {} - client.get_index(request) + client.create_backup_schedule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_index(request) + client.create_backup_schedule(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_index_rest_required_fields(request_type=firestore_admin.GetIndexRequest): - transport_class = transports.FirestoreAdminRestTransport - - 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 +@pytest.mark.asyncio +async def test_create_backup_schedule_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 = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_index._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.create_backup_schedule + in client._client._transport._wrapped_methods + ) - jsonified_request["name"] = "name_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.create_backup_schedule + ] = mock_rpc - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_index._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + request = {} + await client.create_backup_schedule(request) - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + await client.create_backup_schedule(request) - # Designate an appropriate value for the returned response. - return_value = index.Index() - # 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 = index.Index.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_create_backup_schedule_async( + transport: str = "grpc_asyncio", + request_type=firestore_admin.CreateBackupScheduleRequest, +): + client = FirestoreAdminAsyncClient( + 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.get_index(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule( + name="name_value", + ) + ) + response = await client.create_backup_schedule(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 = firestore_admin.CreateBackupScheduleRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, schedule.BackupSchedule) + assert response.name == "name_value" -def test_get_index_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.get_index._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) +@pytest.mark.asyncio +async def test_create_backup_schedule_async_from_dict(): + await test_create_backup_schedule_async(request_type=dict) -def test_get_index_rest_flattened(): +def test_create_backup_schedule_field_headers(): client = FirestoreAdminClient( 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 = index.Index() - - # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" - } + # 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 = firestore_admin.CreateBackupScheduleRequest() - # get truthy value for each flattened field - mock_args = dict( - name="name_value", - ) - mock_args.update(sample_request) + request.parent = "parent_value" - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - # Convert return value to protobuf type - return_value = index.Index.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_backup_schedule), "__call__" + ) as call: + call.return_value = schedule.BackupSchedule() + client.create_backup_schedule(request) - client.get_index(**mock_args) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request - # Establish that the underlying call was made with the expected - # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{name=projects/*/databases/*/collectionGroups/*/indexes/*}" - % client.transport._host, - args[1], + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_create_backup_schedule_field_headers_async(): + client = FirestoreAdminAsyncClient( + 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 = firestore_admin.CreateBackupScheduleRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule() ) + await client.create_backup_schedule(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request -def test_get_index_rest_flattened_error(transport: str = "rest"): + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_create_backup_schedule_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.create_backup_schedule( + parent="parent_value", + backup_schedule=schedule.BackupSchedule(name="name_value"), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].backup_schedule + mock_val = schedule.BackupSchedule(name="name_value") + assert arg == mock_val + + +def test_create_backup_schedule_flattened_error(): client = FirestoreAdminClient( 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_index( - firestore_admin.GetIndexRequest(), + client.create_backup_schedule( + firestore_admin.CreateBackupScheduleRequest(), + parent="parent_value", + backup_schedule=schedule.BackupSchedule(name="name_value"), + ) + + +@pytest.mark.asyncio +async def test_create_backup_schedule_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.create_backup_schedule( + parent="parent_value", + backup_schedule=schedule.BackupSchedule(name="name_value"), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val + arg = args[0].backup_schedule + mock_val = schedule.BackupSchedule(name="name_value") + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_create_backup_schedule_flattened_error_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.create_backup_schedule( + firestore_admin.CreateBackupScheduleRequest(), + parent="parent_value", + backup_schedule=schedule.BackupSchedule(name="name_value"), + ) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.GetBackupScheduleRequest, + dict, + ], +) +def test_get_backup_schedule(request_type, transport: str = "grpc"): + client = FirestoreAdminClient( + 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_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule( name="name_value", ) + response = client.get_backup_schedule(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.GetBackupScheduleRequest() + assert args[0] == request -def test_delete_index_rest_use_cached_wrapped_rpc(): + # Establish that the response is the type that we expect. + assert isinstance(response, schedule.BackupSchedule) + assert response.name == "name_value" + + +def test_get_backup_schedule_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 = FirestoreAdminClient( + 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 = firestore_admin.GetBackupScheduleRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_backup_schedule), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.get_backup_schedule(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.GetBackupScheduleRequest( + name="name_value", + ) + + +def test_get_backup_schedule_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10090,352 +10582,338 @@ def test_delete_index_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_index in client._transport._wrapped_methods + assert ( + client._transport.get_backup_schedule 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_index] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.get_backup_schedule + ] = mock_rpc request = {} - client.delete_index(request) + client.get_backup_schedule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_index(request) + client.get_backup_schedule(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_index_rest_required_fields( - request_type=firestore_admin.DeleteIndexRequest, +@pytest.mark.asyncio +async def test_get_backup_schedule_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.FirestoreAdminRestTransport - - 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_index._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Clients should use _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 = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - # verify required fields with default values are now present + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - jsonified_request["name"] = "name_value" + # Ensure method has been cached + assert ( + client._client._transport.get_backup_schedule + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).delete_index._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_backup_schedule + ] = mock_rpc - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + request = {} + await client.get_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.get_backup_schedule(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_backup_schedule_async( + transport: str = "grpc_asyncio", + request_type=firestore_admin.GetBackupScheduleRequest, +): + client = FirestoreAdminAsyncClient( + 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_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule( + name="name_value", + ) + ) + response = await client.get_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = firestore_admin.GetBackupScheduleRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, schedule.BackupSchedule) + assert response.name == "name_value" + + +@pytest.mark.asyncio +async def test_get_backup_schedule_async_from_dict(): + await test_get_backup_schedule_async(request_type=dict) + +def test_get_backup_schedule_field_headers(): client = FirestoreAdminClient( 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 = firestore_admin.GetBackupScheduleRequest() - response_value = Response() - response_value.status_code = 200 - json_return_value = "" + request.name = "name_value" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_backup_schedule), "__call__" + ) as call: + call.return_value = schedule.BackupSchedule() + client.get_backup_schedule(request) - response = client.delete_index(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] -def test_delete_index_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_get_backup_schedule_field_headers_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.delete_index._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 = firestore_admin.GetBackupScheduleRequest() + request.name = "name_value" -def test_delete_index_rest_flattened(): + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_backup_schedule), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule() + ) + await client.get_backup_schedule(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_backup_schedule_flattened(): client = FirestoreAdminClient( 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/databases/sample2/collectionGroups/sample3/indexes/sample4" - } - - # 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_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_backup_schedule( 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_index(**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/*/databases/*/collectionGroups/*/indexes/*}" - % client.transport._host, - args[1], - ) + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val -def test_delete_index_rest_flattened_error(transport: str = "rest"): +def test_get_backup_schedule_flattened_error(): client = FirestoreAdminClient( 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_index( - firestore_admin.DeleteIndexRequest(), + client.get_backup_schedule( + firestore_admin.GetBackupScheduleRequest(), name="name_value", ) -def test_get_field_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 = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +@pytest.mark.asyncio +async def test_get_backup_schedule_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) - # Ensure method has been cached - assert client._transport.get_field in client._transport._wrapped_methods + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.get_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule() - # Replace cached wrapped function with mock - mock_rpc = mock.Mock() - mock_rpc.return_value.name = ( - "foo" # operation_request.operation in compute client(s) expect a string. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_backup_schedule( + name="name_value", ) - client._transport._wrapped_methods[client._transport.get_field] = mock_rpc - - request = {} - client.get_field(request) - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val - client.get_field(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_field_rest_required_fields(request_type=firestore_admin.GetFieldRequest): - transport_class = transports.FirestoreAdminRestTransport - - 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) +@pytest.mark.asyncio +async def test_get_backup_schedule_flattened_error_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).get_field._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_field._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_backup_schedule( + firestore_admin.GetBackupScheduleRequest(), + name="name_value", + ) - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.ListBackupSchedulesRequest, + dict, + ], +) +def test_list_backup_schedules(request_type, transport: str = "grpc"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = field.Field() - # 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 = field.Field.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - - response_value._content = json_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_field(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = firestore_admin.ListBackupSchedulesResponse() + response = client.list_backup_schedules(request) -def test_get_field_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.ListBackupSchedulesRequest() + assert args[0] == request - unset_fields = transport.get_field._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + # Establish that the response is the type that we expect. + assert isinstance(response, firestore_admin.ListBackupSchedulesResponse) -def test_get_field_rest_flattened(): +def test_list_backup_schedules_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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = field.Field() - - # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/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 - # Convert return value to protobuf type - return_value = field.Field.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_field(**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/*/databases/*/collectionGroups/*/fields/*}" - % client.transport._host, - args[1], - ) - - -def test_get_field_rest_flattened_error(transport: str = "rest"): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + # 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 = firestore_admin.ListBackupSchedulesRequest( + parent="parent_value", ) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.get_field( - firestore_admin.GetFieldRequest(), - name="name_value", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.list_backup_schedules(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.ListBackupSchedulesRequest( + parent="parent_value", ) -def test_update_field_rest_use_cached_wrapped_rpc(): +def test_list_backup_schedules_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -10443,620 +10921,685 @@ def test_update_field_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_field in client._transport._wrapped_methods + assert ( + client._transport.list_backup_schedules + 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_field] = mock_rpc - + client._transport._wrapped_methods[ + client._transport.list_backup_schedules + ] = mock_rpc request = {} - client.update_field(request) + client.list_backup_schedules(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.update_field(request) + client.list_backup_schedules(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_field_rest_required_fields( - request_type=firestore_admin.UpdateFieldRequest, +@pytest.mark.asyncio +async def test_list_backup_schedules_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", ): - transport_class = transports.FirestoreAdminRestTransport + # Clients should use _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 = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) - request_init = {} - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson(pb_request, use_integers_for_enums=False) - ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # verify fields with default values are dropped + # Ensure method has been cached + assert ( + client._client._transport.list_backup_schedules + in client._client._transport._wrapped_methods + ) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_field._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_backup_schedules + ] = mock_rpc - # verify required fields with default values are now present + request = {} + await client.list_backup_schedules(request) - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).update_field._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) - jsonified_request.update(unset_fields) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 - # verify required fields with non-default values are left alone + await client.list_backup_schedules(request) - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "patch", - "query_params": pb_request, - } - transcode_result["body"] = pb_request - transcode.return_value = transcode_result - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) +@pytest.mark.asyncio +async def test_list_backup_schedules_async( + transport: str = "grpc_asyncio", + request_type=firestore_admin.ListBackupSchedulesRequest, +): + client = FirestoreAdminAsyncClient( + 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.update_field(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupSchedulesResponse() + ) + response = await client.list_backup_schedules(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 = firestore_admin.ListBackupSchedulesRequest() + assert args[0] == request + # Establish that the response is the type that we expect. + assert isinstance(response, firestore_admin.ListBackupSchedulesResponse) -def test_update_field_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) - unset_fields = transport.update_field._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("field",))) +@pytest.mark.asyncio +async def test_list_backup_schedules_async_from_dict(): + await test_list_backup_schedules_async(request_type=dict) -def test_update_field_rest_flattened(): +def test_list_backup_schedules_field_headers(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + # 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 = firestore_admin.ListBackupSchedulesRequest() - # get arguments that satisfy an http rule for this method - sample_request = { - "field": { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" - } - } + request.parent = "parent_value" - # get truthy value for each flattened field - mock_args = dict( - field=gfa_field.Field(name="name_value"), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + call.return_value = firestore_admin.ListBackupSchedulesResponse() + client.list_backup_schedules(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_backup_schedules_field_headers_async(): + client = FirestoreAdminAsyncClient( + 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 = firestore_admin.ListBackupSchedulesRequest() + + request.parent = "parent_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupSchedulesResponse() ) - mock_args.update(sample_request) + await client.list_backup_schedules(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"} + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request - client.update_field(**mock_args) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "parent=parent_value", + ) in kw["metadata"] + + +def test_list_backup_schedules_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = firestore_admin.ListBackupSchedulesResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_backup_schedules( + 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/{field.name=projects/*/databases/*/collectionGroups/*/fields/*}" - % client.transport._host, - args[1], - ) + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val -def test_update_field_rest_flattened_error(transport: str = "rest"): +def test_list_backup_schedules_flattened_error(): client = FirestoreAdminClient( 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_field( - firestore_admin.UpdateFieldRequest(), - field=gfa_field.Field(name="name_value"), + client.list_backup_schedules( + firestore_admin.ListBackupSchedulesRequest(), + parent="parent_value", ) -def test_list_fields_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 = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +@pytest.mark.asyncio +async def test_list_backup_schedules_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) - # Ensure method has been cached - assert client._transport.list_fields in client._transport._wrapped_methods + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = firestore_admin.ListBackupSchedulesResponse() - # Replace cached wrapped function with mock - mock_rpc = mock.Mock() - mock_rpc.return_value.name = ( - "foo" # operation_request.operation in compute client(s) expect a string. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupSchedulesResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_backup_schedules( + parent="parent_value", ) - client._transport._wrapped_methods[client._transport.list_fields] = mock_rpc - request = {} - client.list_fields(request) + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].parent + mock_val = "parent_value" + assert arg == mock_val - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - client.list_fields(request) +@pytest.mark.asyncio +async def test_list_backup_schedules_flattened_error_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) - # Establish that a new wrapper was not created for this call - assert wrapper_fn.call_count == 0 - assert mock_rpc.call_count == 2 + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.list_backup_schedules( + firestore_admin.ListBackupSchedulesRequest(), + parent="parent_value", + ) -def test_list_fields_rest_required_fields( - request_type=firestore_admin.ListFieldsRequest, -): - transport_class = transports.FirestoreAdminRestTransport - - 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.parametrize( + "request_type", + [ + firestore_admin.UpdateBackupScheduleRequest, + dict, + ], +) +def test_update_backup_schedule(request_type, transport: str = "grpc"): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # verify fields with default values are dropped - - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_fields._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # 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() - # 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.update_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule( + name="name_value", + ) + response = client.update_backup_schedule(request) - jsonified_request["parent"] = "parent_value" + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.UpdateBackupScheduleRequest() + assert args[0] == request - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_fields._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "filter", - "page_size", - "page_token", - ) - ) - jsonified_request.update(unset_fields) + # Establish that the response is the type that we expect. + assert isinstance(response, schedule.BackupSchedule) + assert response.name == "name_value" - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" +def test_update_backup_schedule_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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) - request = request_type(**request_init) - - # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListFieldsResponse() - # 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 = firestore_admin.ListFieldsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = firestore_admin.UpdateBackupScheduleRequest() - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_backup_schedule), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.update_backup_schedule(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.UpdateBackupScheduleRequest() - response = client.list_fields(request) - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params +def test_update_backup_schedule_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -def test_list_fields_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) + # Ensure method has been cached + assert ( + client._transport.update_backup_schedule + in client._transport._wrapped_methods + ) - unset_fields = transport.list_fields._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "pageSize", - "pageToken", - ) + # 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. ) - & set(("parent",)) - ) + client._transport._wrapped_methods[ + client._transport.update_backup_schedule + ] = mock_rpc + request = {} + client.update_backup_schedule(request) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 -def test_list_fields_rest_flattened(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) + client.update_backup_schedule(request) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListFieldsResponse() + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # get arguments that satisfy an http rule for this method - sample_request = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } - # get truthy value for each flattened field - mock_args = dict( - parent="parent_value", +@pytest.mark.asyncio +async def test_update_backup_schedule_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 = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - 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 = firestore_admin.ListFieldsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) - response_value._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_fields(**mock_args) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() - # 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/*/databases/*/collectionGroups/*}/fields" - % client.transport._host, - args[1], + # Ensure method has been cached + assert ( + client._client._transport.update_backup_schedule + in client._client._transport._wrapped_methods ) + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.update_backup_schedule + ] = mock_rpc -def test_list_fields_rest_flattened_error(transport: str = "rest"): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, - ) + request = {} + await client.update_backup_schedule(request) - # Attempting to call a method with both a request object and flattened - # fields is an error. - with pytest.raises(ValueError): - client.list_fields( - firestore_admin.ListFieldsRequest(), - parent="parent_value", - ) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + await client.update_backup_schedule(request) -def test_list_fields_rest_pager(transport: str = "rest"): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_update_backup_schedule_async( + transport: str = "grpc_asyncio", + request_type=firestore_admin.UpdateBackupScheduleRequest, +): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), transport=transport, ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # TODO(kbandes): remove this mock unless there's a good reason for it. - # with mock.patch.object(path_template, 'transcode') as transcode: - # Set the response as a series of pages - response = ( - firestore_admin.ListFieldsResponse( - fields=[ - field.Field(), - field.Field(), - field.Field(), - ], - next_page_token="abc", - ), - firestore_admin.ListFieldsResponse( - fields=[], - next_page_token="def", - ), - firestore_admin.ListFieldsResponse( - fields=[ - field.Field(), - ], - next_page_token="ghi", - ), - firestore_admin.ListFieldsResponse( - fields=[ - field.Field(), - field.Field(), - ], - ), - ) - # 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( - firestore_admin.ListFieldsResponse.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.update_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule( + name="name_value", + ) ) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - - sample_request = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } + response = await client.update_backup_schedule(request) - pager = client.list_fields(request=sample_request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = firestore_admin.UpdateBackupScheduleRequest() + assert args[0] == request - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, field.Field) for i in results) + # Establish that the response is the type that we expect. + assert isinstance(response, schedule.BackupSchedule) + assert response.name == "name_value" - pages = list(client.list_fields(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token +@pytest.mark.asyncio +async def test_update_backup_schedule_async_from_dict(): + await test_update_backup_schedule_async(request_type=dict) -def test_export_documents_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 = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - # Should wrap all calls on client creation - assert wrapper_fn.call_count > 0 - wrapper_fn.reset_mock() +def test_update_backup_schedule_field_headers(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + ) - # Ensure method has been cached - assert client._transport.export_documents 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 = firestore_admin.UpdateBackupScheduleRequest() - # 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.export_documents - ] = mock_rpc + request.backup_schedule.name = "name_value" - request = {} - client.export_documents(request) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_backup_schedule), "__call__" + ) as call: + call.return_value = schedule.BackupSchedule() + client.update_backup_schedule(request) # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.export_documents(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", + "backup_schedule.name=name_value", + ) in kw["metadata"] -def test_export_documents_rest_required_fields( - request_type=firestore_admin.ExportDocumentsRequest, -): - transport_class = transports.FirestoreAdminRestTransport - 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) +@pytest.mark.asyncio +async def test_update_backup_schedule_field_headers_async(): + client = FirestoreAdminAsyncClient( + 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 = firestore_admin.UpdateBackupScheduleRequest() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).export_documents._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + request.backup_schedule.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.update_backup_schedule), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule() + ) + await client.update_backup_schedule(request) - jsonified_request["name"] = "name_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() - ).export_documents._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "backup_schedule.name=name_value", + ) in kw["metadata"] - # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" +def test_update_backup_schedule_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "post", - "query_params": pb_request, - } - transcode_result["body"] = pb_request - transcode.return_value = transcode_result + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.update_backup_schedule( + backup_schedule=schedule.BackupSchedule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) - response_value = Response() - response_value.status_code = 200 - 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].backup_schedule + mock_val = schedule.BackupSchedule(name="name_value") + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.export_documents(request) +def test_update_backup_schedule_flattened_error(): + client = FirestoreAdminClient( + 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.update_backup_schedule( + firestore_admin.UpdateBackupScheduleRequest(), + backup_schedule=schedule.BackupSchedule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) -def test_export_documents_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_update_backup_schedule_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.export_documents._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) - - -def test_export_documents_rest_flattened(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") - - # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/databases/sample2"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = schedule.BackupSchedule() - # get truthy value for each flattened field - mock_args = dict( - name="name_value", + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.update_backup_schedule( + backup_schedule=schedule.BackupSchedule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) - mock_args.update(sample_request) - - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - - client.export_documents(**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/*/databases/*}:exportDocuments" - % client.transport._host, - args[1], + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].backup_schedule + mock_val = schedule.BackupSchedule(name="name_value") + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_update_backup_schedule_flattened_error_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.update_backup_schedule( + firestore_admin.UpdateBackupScheduleRequest(), + backup_schedule=schedule.BackupSchedule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_export_documents_rest_flattened_error(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.DeleteBackupScheduleRequest, + dict, + ], +) +def test_delete_backup_schedule(request_type, transport: str = "grpc"): client = FirestoreAdminClient( 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.export_documents( - firestore_admin.ExportDocumentsRequest(), + # 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_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = firestore_admin.DeleteBackupScheduleRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_backup_schedule_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 = FirestoreAdminClient( + 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 = firestore_admin.DeleteBackupScheduleRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_backup_schedule(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == firestore_admin.DeleteBackupScheduleRequest( name="name_value", ) -def test_import_documents_rest_use_cached_wrapped_rpc(): +def test_delete_backup_schedule_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create 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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport="grpc", ) # Should wrap all calls on client creation @@ -11064,7 +11607,10 @@ def test_import_documents_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.import_documents in client._transport._wrapped_methods + assert ( + client._transport.delete_backup_schedule + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -11072,165 +11618,248 @@ def test_import_documents_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.import_documents + client._transport.delete_backup_schedule ] = mock_rpc - request = {} - client.import_documents(request) + client.delete_backup_schedule(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper + client.delete_backup_schedule(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_backup_schedule_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 = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 wrapper_fn.reset_mock() - client.import_documents(request) + # Ensure method has been cached + assert ( + client._client._transport.delete_backup_schedule + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.delete_backup_schedule + ] = mock_rpc + + request = {} + await client.delete_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.delete_backup_schedule(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_import_documents_rest_required_fields( - request_type=firestore_admin.ImportDocumentsRequest, +@pytest.mark.asyncio +async def test_delete_backup_schedule_async( + transport: str = "grpc_asyncio", + request_type=firestore_admin.DeleteBackupScheduleRequest, ): - transport_class = transports.FirestoreAdminRestTransport - - 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) + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, ) - # verify fields with default values are dropped + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).import_documents._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_backup_schedule(request) - # verify required fields with default values are now present + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = firestore_admin.DeleteBackupScheduleRequest() + assert args[0] == request - jsonified_request["name"] = "name_value" + # Establish that the response is the type that we expect. + assert response is None - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).import_documents._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" +@pytest.mark.asyncio +async def test_delete_backup_schedule_async_from_dict(): + await test_delete_backup_schedule_async(request_type=dict) + +def test_delete_backup_schedule_field_headers(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - request = request_type(**request_init) - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") - # Mock the http request call within the method and fake a response. - with mock.patch.object(Session, "request") as req: - # We need to mock transcode() because providing default values - # for required fields will fail the real version if the http_options - # expect actual values for those fields. - with mock.patch.object(path_template, "transcode") as transcode: - # A uri without fields and an empty body will force all the - # request fields to show up in the query_params. - pb_request = request_type.pb(request) - transcode_result = { - "uri": "v1/sample_method", - "method": "post", - "query_params": pb_request, - } - transcode_result["body"] = pb_request - transcode.return_value = transcode_result + # 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 = firestore_admin.DeleteBackupScheduleRequest() - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) + request.name = "name_value" - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__call__" + ) as call: + call.return_value = None + client.delete_backup_schedule(request) - response = client.import_documents(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] -def test_import_documents_rest_unset_required_fields(): - transport = transports.FirestoreAdminRestTransport( - credentials=ga_credentials.AnonymousCredentials +@pytest.mark.asyncio +async def test_delete_backup_schedule_field_headers_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), ) - unset_fields = transport.import_documents._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 = firestore_admin.DeleteBackupScheduleRequest() + + request.name = "name_value" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_backup_schedule(request) -def test_import_documents_rest_flattened(): + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "name=name_value", + ) in kw["metadata"] + + +def test_delete_backup_schedule_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", ) - # Mock the http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__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_backup_schedule( + name="name_value", + ) - # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/databases/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].name + mock_val = "name_value" + assert arg == mock_val - # get truthy value for each flattened field - mock_args = dict( + +def test_delete_backup_schedule_flattened_error(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_backup_schedule( + firestore_admin.DeleteBackupScheduleRequest(), name="name_value", ) - mock_args.update(sample_request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.import_documents(**mock_args) +@pytest.mark.asyncio +async def test_delete_backup_schedule_flattened_async(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__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_backup_schedule( + 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/{name=projects/*/databases/*}:importDocuments" - % client.transport._host, - args[1], - ) + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val -def test_import_documents_rest_flattened_error(transport: str = "rest"): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, +@pytest.mark.asyncio +async def test_delete_backup_schedule_flattened_error_async(): + client = FirestoreAdminAsyncClient( + 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.import_documents( - firestore_admin.ImportDocumentsRequest(), + await client.delete_backup_schedule( + firestore_admin.DeleteBackupScheduleRequest(), name="name_value", ) -def test_bulk_delete_documents_rest_use_cached_wrapped_rpc(): +def test_create_index_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: @@ -11244,22 +11873,17 @@ def test_bulk_delete_documents_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.bulk_delete_documents - in client._transport._wrapped_methods - ) + assert client._transport.create_index 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.bulk_delete_documents - ] = mock_rpc + client._transport._wrapped_methods[client._transport.create_index] = mock_rpc request = {} - client.bulk_delete_documents(request) + client.create_index(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 @@ -11268,20 +11892,20 @@ def test_bulk_delete_documents_rest_use_cached_wrapped_rpc(): # subsequent calls should use the cached wrapper wrapper_fn.reset_mock() - client.bulk_delete_documents(request) + client.create_index(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_bulk_delete_documents_rest_required_fields( - request_type=firestore_admin.BulkDeleteDocumentsRequest, +def test_create_index_rest_required_fields( + request_type=firestore_admin.CreateIndexRequest, ): transport_class = transports.FirestoreAdminRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -11292,21 +11916,21 @@ def test_bulk_delete_documents_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).bulk_delete_documents._get_unset_required_fields(jsonified_request) + ).create_index._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() - ).bulk_delete_documents._get_unset_required_fields(jsonified_request) + ).create_index._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11341,23 +11965,31 @@ def test_bulk_delete_documents_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.bulk_delete_documents(request) + response = client.create_index(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_bulk_delete_documents_rest_unset_required_fields(): +def test_create_index_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.bulk_delete_documents._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.create_index._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "index", + ) + ) + ) -def test_bulk_delete_documents_rest_flattened(): +def test_create_index_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -11369,11 +12001,14 @@ def test_bulk_delete_documents_rest_flattened(): return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/databases/sample2"} + sample_request = { + "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", + index=gfa_index.Index(name="name_value"), ) mock_args.update(sample_request) @@ -11385,20 +12020,20 @@ def test_bulk_delete_documents_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.bulk_delete_documents(**mock_args) + client.create_index(**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/*/databases/*}:bulkDeleteDocuments" + "%s/v1/{parent=projects/*/databases/*/collectionGroups/*}/indexes" % client.transport._host, args[1], ) -def test_bulk_delete_documents_rest_flattened_error(transport: str = "rest"): +def test_create_index_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -11407,13 +12042,14 @@ def test_bulk_delete_documents_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.bulk_delete_documents( - firestore_admin.BulkDeleteDocumentsRequest(), - name="name_value", + client.create_index( + firestore_admin.CreateIndexRequest(), + parent="parent_value", + index=gfa_index.Index(name="name_value"), ) -def test_create_database_rest_use_cached_wrapped_rpc(): +def test_list_indexes_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: @@ -11427,40 +12063,35 @@ def test_create_database_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.create_database in client._transport._wrapped_methods + assert client._transport.list_indexes 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_database] = mock_rpc + client._transport._wrapped_methods[client._transport.list_indexes] = mock_rpc request = {} - client.create_database(request) + client.list_indexes(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.create_database(request) + client.list_indexes(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_database_rest_required_fields( - request_type=firestore_admin.CreateDatabaseRequest, +def test_list_indexes_rest_required_fields( + request_type=firestore_admin.ListIndexesRequest, ): transport_class = transports.FirestoreAdminRestTransport request_init = {} request_init["parent"] = "" - request_init["database_id"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -11468,32 +12099,32 @@ def test_create_database_rest_required_fields( ) # verify fields with default values are dropped - assert "databaseId" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_database._get_unset_required_fields(jsonified_request) + ).list_indexes._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "databaseId" in jsonified_request - assert jsonified_request["databaseId"] == request_init["database_id"] jsonified_request["parent"] = "parent_value" - jsonified_request["databaseId"] = "database_id_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_database._get_unset_required_fields(jsonified_request) + ).list_indexes._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("database_id",)) + assert not set(unset_fields) - set( + ( + "filter", + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone assert "parent" in jsonified_request assert jsonified_request["parent"] == "parent_value" - assert "databaseId" in jsonified_request - assert jsonified_request["databaseId"] == "database_id_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11502,7 +12133,7 @@ def test_create_database_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = firestore_admin.ListIndexesResponse() # 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 @@ -11514,52 +12145,48 @@ def test_create_database_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 = firestore_admin.ListIndexesResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_database(request) + response = client.list_indexes(request) - expected_params = [ - ( - "databaseId", - "", - ), - ("$alt", "json;enum-encoding=int"), - ] + expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_database_rest_unset_required_fields(): +def test_list_indexes_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_database._get_unset_required_fields({}) + unset_fields = transport.list_indexes._get_unset_required_fields({}) assert set(unset_fields) == ( - set(("databaseId",)) - & set( + set( ( - "parent", - "database", - "databaseId", + "filter", + "pageSize", + "pageToken", ) ) + & set(("parent",)) ) -def test_create_database_rest_flattened(): +def test_list_indexes_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -11568,39 +12195,43 @@ def test_create_database_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 = operations_pb2.Operation(name="operations/spam") + return_value = firestore_admin.ListIndexesResponse() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1"} + sample_request = { + "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + } # get truthy value for each flattened field mock_args = dict( parent="parent_value", - database=gfa_database.Database(name="name_value"), - database_id="database_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 = firestore_admin.ListIndexesResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_database(**mock_args) + client.list_indexes(**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/*}/databases" % client.transport._host, args[1] + "%s/v1/{parent=projects/*/databases/*/collectionGroups/*}/indexes" + % client.transport._host, + args[1], ) -def test_create_database_rest_flattened_error(transport: str = "rest"): +def test_list_indexes_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -11609,15 +12240,78 @@ def test_create_database_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_database( - firestore_admin.CreateDatabaseRequest(), + client.list_indexes( + firestore_admin.ListIndexesRequest(), parent="parent_value", - database=gfa_database.Database(name="name_value"), - database_id="database_id_value", ) -def test_get_database_rest_use_cached_wrapped_rpc(): +def test_list_indexes_rest_pager(transport: str = "rest"): + client = FirestoreAdminClient( + 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 = ( + firestore_admin.ListIndexesResponse( + indexes=[ + index.Index(), + index.Index(), + index.Index(), + ], + next_page_token="abc", + ), + firestore_admin.ListIndexesResponse( + indexes=[], + next_page_token="def", + ), + firestore_admin.ListIndexesResponse( + indexes=[ + index.Index(), + ], + next_page_token="ghi", + ), + firestore_admin.ListIndexesResponse( + indexes=[ + index.Index(), + index.Index(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + firestore_admin.ListIndexesResponse.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/databases/sample2/collectionGroups/sample3" + } + + pager = client.list_indexes(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, index.Index) for i in results) + + pages = list(client.list_indexes(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_index_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: @@ -11631,31 +12325,29 @@ def test_get_database_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_database in client._transport._wrapped_methods + assert client._transport.get_index 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_database] = mock_rpc + client._transport._wrapped_methods[client._transport.get_index] = mock_rpc request = {} - client.get_database(request) + client.get_index(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_database(request) + client.get_index(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_database_rest_required_fields( - request_type=firestore_admin.GetDatabaseRequest, -): +def test_get_index_rest_required_fields(request_type=firestore_admin.GetIndexRequest): transport_class = transports.FirestoreAdminRestTransport request_init = {} @@ -11670,7 +12362,7 @@ def test_get_database_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_database._get_unset_required_fields(jsonified_request) + ).get_index._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -11679,7 +12371,7 @@ def test_get_database_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_database._get_unset_required_fields(jsonified_request) + ).get_index._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -11693,7 +12385,7 @@ def test_get_database_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = database.Database() + return_value = index.Index() # 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 @@ -11714,30 +12406,30 @@ def test_get_database_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = database.Database.pb(return_value) + return_value = index.Index.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_database(request) + response = client.get_index(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_database_rest_unset_required_fields(): +def test_get_index_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_database._get_unset_required_fields({}) + unset_fields = transport.get_index._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_database_rest_flattened(): +def test_get_index_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -11746,10 +12438,12 @@ def test_get_database_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 = database.Database() + return_value = index.Index() # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/databases/sample2"} + sample_request = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" + } # get truthy value for each flattened field mock_args = dict( @@ -11761,24 +12455,26 @@ def test_get_database_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = database.Database.pb(return_value) + return_value = index.Index.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_database(**mock_args) + client.get_index(**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/*/databases/*}" % client.transport._host, args[1] + "%s/v1/{name=projects/*/databases/*/collectionGroups/*/indexes/*}" + % client.transport._host, + args[1], ) -def test_get_database_rest_flattened_error(transport: str = "rest"): +def test_get_index_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -11787,13 +12483,13 @@ def test_get_database_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_database( - firestore_admin.GetDatabaseRequest(), + client.get_index( + firestore_admin.GetIndexRequest(), name="name_value", ) -def test_list_databases_rest_use_cached_wrapped_rpc(): +def test_delete_index_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: @@ -11807,35 +12503,35 @@ def test_list_databases_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.list_databases in client._transport._wrapped_methods + assert client._transport.delete_index 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_databases] = mock_rpc + client._transport._wrapped_methods[client._transport.delete_index] = mock_rpc request = {} - client.list_databases(request) + client.delete_index(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_databases(request) + client.delete_index(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_databases_rest_required_fields( - request_type=firestore_admin.ListDatabasesRequest, +def test_delete_index_rest_required_fields( + request_type=firestore_admin.DeleteIndexRequest, ): transport_class = transports.FirestoreAdminRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -11846,23 +12542,21 @@ def test_list_databases_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_databases._get_unset_required_fields(jsonified_request) + ).delete_index._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_databases._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("show_deleted",)) + ).delete_index._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -11871,7 +12565,7 @@ def test_list_databases_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListDatabasesResponse() + 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 @@ -11883,39 +12577,36 @@ def test_list_databases_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "delete", "query_params": pb_request, } transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = firestore_admin.ListDatabasesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.list_databases(request) + response = client.delete_index(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_databases_rest_unset_required_fields(): +def test_delete_index_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_databases._get_unset_required_fields({}) - assert set(unset_fields) == (set(("showDeleted",)) & set(("parent",))) + unset_fields = transport.delete_index._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_databases_rest_flattened(): +def test_delete_index_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -11924,39 +12615,41 @@ def test_list_databases_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 = firestore_admin.ListDatabasesResponse() + return_value = None # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1"} + sample_request = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" + } # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = firestore_admin.ListDatabasesResponse.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_return_value = "" response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.list_databases(**mock_args) + client.delete_index(**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/*}/databases" % client.transport._host, args[1] + "%s/v1/{name=projects/*/databases/*/collectionGroups/*/indexes/*}" + % client.transport._host, + args[1], ) -def test_list_databases_rest_flattened_error(transport: str = "rest"): +def test_delete_index_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -11965,13 +12658,13 @@ def test_list_databases_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_databases( - firestore_admin.ListDatabasesRequest(), - parent="parent_value", + client.delete_index( + firestore_admin.DeleteIndexRequest(), + name="name_value", ) -def test_update_database_rest_use_cached_wrapped_rpc(): +def test_get_field_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: @@ -11985,38 +12678,33 @@ def test_update_database_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.update_database in client._transport._wrapped_methods + assert client._transport.get_field 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_database] = mock_rpc + client._transport._wrapped_methods[client._transport.get_field] = mock_rpc request = {} - client.update_database(request) + client.get_field(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - # Operation methods build a cached wrapper on first rpc call - # subsequent calls should use the cached wrapper - wrapper_fn.reset_mock() - - client.update_database(request) + client.get_field(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_database_rest_required_fields( - request_type=firestore_admin.UpdateDatabaseRequest, -): +def test_get_field_rest_required_fields(request_type=firestore_admin.GetFieldRequest): transport_class = transports.FirestoreAdminRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -12027,19 +12715,21 @@ def test_update_database_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_database._get_unset_required_fields(jsonified_request) + ).get_field._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_database._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("update_mask",)) + ).get_field._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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12048,7 +12738,7 @@ def test_update_database_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = field.Field() # 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 @@ -12060,37 +12750,39 @@ def test_update_database_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = field.Field.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_database(request) + response = client.get_field(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_database_rest_unset_required_fields(): +def test_get_field_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_database._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("database",))) + unset_fields = transport.get_field._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_update_database_rest_flattened(): +def test_get_field_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12099,39 +12791,43 @@ def test_update_database_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 = operations_pb2.Operation(name="operations/spam") + return_value = field.Field() # get arguments that satisfy an http rule for this method - sample_request = {"database": {"name": "projects/sample1/databases/sample2"}} + sample_request = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" + } # get truthy value for each flattened field mock_args = dict( - database=gfa_database.Database(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + name="name_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 + # Convert return value to protobuf type + return_value = field.Field.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_database(**mock_args) + client.get_field(**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/{database.name=projects/*/databases/*}" % client.transport._host, + "%s/v1/{name=projects/*/databases/*/collectionGroups/*/fields/*}" + % client.transport._host, args[1], ) -def test_update_database_rest_flattened_error(transport: str = "rest"): +def test_get_field_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12140,14 +12836,13 @@ def test_update_database_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_database( - firestore_admin.UpdateDatabaseRequest(), - database=gfa_database.Database(name="name_value"), - update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + client.get_field( + firestore_admin.GetFieldRequest(), + name="name_value", ) -def test_delete_database_rest_use_cached_wrapped_rpc(): +def test_update_field_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: @@ -12161,17 +12856,17 @@ def test_delete_database_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_database in client._transport._wrapped_methods + assert client._transport.update_field 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_database] = mock_rpc + client._transport._wrapped_methods[client._transport.update_field] = mock_rpc request = {} - client.delete_database(request) + client.update_field(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 @@ -12180,20 +12875,19 @@ def test_delete_database_rest_use_cached_wrapped_rpc(): # subsequent calls should use the cached wrapper wrapper_fn.reset_mock() - client.delete_database(request) + client.update_field(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_database_rest_required_fields( - request_type=firestore_admin.DeleteDatabaseRequest, +def test_update_field_rest_required_fields( + request_type=firestore_admin.UpdateFieldRequest, ): transport_class = transports.FirestoreAdminRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -12204,23 +12898,19 @@ def test_delete_database_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_database._get_unset_required_fields(jsonified_request) + ).update_field._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_database._get_unset_required_fields(jsonified_request) + ).update_field._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("etag",)) + assert not set(unset_fields) - set(("update_mask",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12241,9 +12931,10 @@ def test_delete_database_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "delete", + "method": "patch", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() @@ -12254,23 +12945,23 @@ def test_delete_database_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.delete_database(request) + response = client.update_field(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_database_rest_unset_required_fields(): +def test_update_field_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_database._get_unset_required_fields({}) - assert set(unset_fields) == (set(("etag",)) & set(("name",))) + unset_fields = transport.update_field._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("field",))) -def test_delete_database_rest_flattened(): +def test_update_field_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12282,11 +12973,15 @@ def test_delete_database_rest_flattened(): return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/databases/sample2"} + sample_request = { + "field": { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" + } + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + field=gfa_field.Field(name="name_value"), ) mock_args.update(sample_request) @@ -12298,18 +12993,20 @@ def test_delete_database_rest_flattened(): req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_database(**mock_args) + client.update_field(**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/*/databases/*}" % client.transport._host, args[1] + "%s/v1/{field.name=projects/*/databases/*/collectionGroups/*/fields/*}" + % client.transport._host, + args[1], ) -def test_delete_database_rest_flattened_error(transport: str = "rest"): +def test_update_field_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12318,13 +13015,13 @@ def test_delete_database_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_database( - firestore_admin.DeleteDatabaseRequest(), - name="name_value", + client.update_field( + firestore_admin.UpdateFieldRequest(), + field=gfa_field.Field(name="name_value"), ) -def test_get_backup_rest_use_cached_wrapped_rpc(): +def test_list_fields_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: @@ -12338,33 +13035,35 @@ def test_get_backup_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.get_backup in client._transport._wrapped_methods + assert client._transport.list_fields 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_backup] = mock_rpc + client._transport._wrapped_methods[client._transport.list_fields] = mock_rpc request = {} - client.get_backup(request) + client.list_fields(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_backup(request) + client.list_fields(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_backup_rest_required_fields(request_type=firestore_admin.GetBackupRequest): +def test_list_fields_rest_required_fields( + request_type=firestore_admin.ListFieldsRequest, +): transport_class = transports.FirestoreAdminRestTransport request_init = {} - request_init["name"] = "" + request_init["parent"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -12375,21 +13074,29 @@ def test_get_backup_rest_required_fields(request_type=firestore_admin.GetBackupR unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_backup._get_unset_required_fields(jsonified_request) + ).list_fields._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_backup._get_unset_required_fields(jsonified_request) + ).list_fields._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "page_size", + "page_token", + ) + ) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12398,7 +13105,7 @@ def test_get_backup_rest_required_fields(request_type=firestore_admin.GetBackupR request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = backup.Backup() + return_value = firestore_admin.ListFieldsResponse() # 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 @@ -12419,30 +13126,39 @@ def test_get_backup_rest_required_fields(request_type=firestore_admin.GetBackupR response_value.status_code = 200 # Convert return value to protobuf type - return_value = backup.Backup.pb(return_value) + return_value = firestore_admin.ListFieldsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup(request) + response = client.list_fields(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_backup_rest_unset_required_fields(): +def test_list_fields_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_backup._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.list_fields._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) -def test_get_backup_rest_flattened(): +def test_list_fields_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12451,14 +13167,16 @@ def test_get_backup_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 = backup.Backup() + return_value = firestore_admin.ListFieldsResponse() # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/locations/sample2/backups/sample3"} + sample_request = { + "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + } # get truthy value for each flattened field mock_args = dict( - name="name_value", + parent="parent_value", ) mock_args.update(sample_request) @@ -12466,25 +13184,26 @@ def test_get_backup_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = backup.Backup.pb(return_value) + return_value = firestore_admin.ListFieldsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_backup(**mock_args) + client.list_fields(**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/*/backups/*}" % client.transport._host, + "%s/v1/{parent=projects/*/databases/*/collectionGroups/*}/fields" + % client.transport._host, args[1], ) -def test_get_backup_rest_flattened_error(transport: str = "rest"): +def test_list_fields_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12493,55 +13212,126 @@ def test_get_backup_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_backup( - firestore_admin.GetBackupRequest(), - name="name_value", - ) - - -def test_list_backups_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 = FirestoreAdminClient( - 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_backups 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_fields( + firestore_admin.ListFieldsRequest(), + parent="parent_value", ) - client._transport._wrapped_methods[client._transport.list_backups] = mock_rpc - - request = {} - client.list_backups(request) - - # Establish that the underlying gRPC stub method was called. - assert mock_rpc.call_count == 1 - - client.list_backups(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_fields_rest_pager(transport: str = "rest"): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) -def test_list_backups_rest_required_fields( - request_type=firestore_admin.ListBackupsRequest, -): - transport_class = transports.FirestoreAdminRestTransport + # 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 = ( + firestore_admin.ListFieldsResponse( + fields=[ + field.Field(), + field.Field(), + field.Field(), + ], + next_page_token="abc", + ), + firestore_admin.ListFieldsResponse( + fields=[], + next_page_token="def", + ), + firestore_admin.ListFieldsResponse( + fields=[ + field.Field(), + ], + next_page_token="ghi", + ), + firestore_admin.ListFieldsResponse( + fields=[ + field.Field(), + field.Field(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + firestore_admin.ListFieldsResponse.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/databases/sample2/collectionGroups/sample3" + } + + pager = client.list_fields(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, field.Field) for i in results) + + pages = list(client.list_fields(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_export_documents_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 = FirestoreAdminClient( + 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.export_documents 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.export_documents + ] = mock_rpc + + request = {} + client.export_documents(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.export_documents(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_export_documents_rest_required_fields( + request_type=firestore_admin.ExportDocumentsRequest, +): + transport_class = transports.FirestoreAdminRestTransport request_init = {} - request_init["parent"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -12552,23 +13342,21 @@ def test_list_backups_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_backups._get_unset_required_fields(jsonified_request) + ).export_documents._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_backups._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("filter",)) + ).export_documents._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12577,7 +13365,7 @@ def test_list_backups_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListBackupsResponse() + return_value = operations_pb2.Operation(name="operations/spam") # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -12589,39 +13377,37 @@ def test_list_backups_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 = firestore_admin.ListBackupsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backups(request) + response = client.export_documents(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_backups_rest_unset_required_fields(): +def test_export_documents_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_backups._get_unset_required_fields({}) - assert set(unset_fields) == (set(("filter",)) & set(("parent",))) + unset_fields = transport.export_documents._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -def test_list_backups_rest_flattened(): +def test_export_documents_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12630,40 +13416,39 @@ def test_list_backups_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 = firestore_admin.ListBackupsResponse() + return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + sample_request = {"name": "projects/sample1/databases/sample2"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", + name="name_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = firestore_admin.ListBackupsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_backups(**mock_args) + client.export_documents(**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/*}/backups" % client.transport._host, + "%s/v1/{name=projects/*/databases/*}:exportDocuments" + % client.transport._host, args[1], ) -def test_list_backups_rest_flattened_error(transport: str = "rest"): +def test_export_documents_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12672,13 +13457,13 @@ def test_list_backups_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_backups( - firestore_admin.ListBackupsRequest(), - parent="parent_value", + client.export_documents( + firestore_admin.ExportDocumentsRequest(), + name="name_value", ) -def test_delete_backup_rest_use_cached_wrapped_rpc(): +def test_import_documents_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,30 +13477,36 @@ def test_delete_backup_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.delete_backup in client._transport._wrapped_methods + assert client._transport.import_documents 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_backup] = mock_rpc + client._transport._wrapped_methods[ + client._transport.import_documents + ] = mock_rpc request = {} - client.delete_backup(request) + client.import_documents(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_backup(request) + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.import_documents(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_backup_rest_required_fields( - request_type=firestore_admin.DeleteBackupRequest, +def test_import_documents_rest_required_fields( + request_type=firestore_admin.ImportDocumentsRequest, ): transport_class = transports.FirestoreAdminRestTransport @@ -12731,7 +13522,7 @@ def test_delete_backup_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_backup._get_unset_required_fields(jsonified_request) + ).import_documents._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -12740,7 +13531,7 @@ def test_delete_backup_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_backup._get_unset_required_fields(jsonified_request) + ).import_documents._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -12754,7 +13545,7 @@ def test_delete_backup_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = operations_pb2.Operation(name="operations/spam") # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -12766,36 +13557,37 @@ def test_delete_backup_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 = "" + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup(request) + response = client.import_documents(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_backup_rest_unset_required_fields(): +def test_import_documents_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_backup._get_unset_required_fields({}) + unset_fields = transport.import_documents._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_delete_backup_rest_flattened(): +def test_import_documents_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -12804,10 +13596,10 @@ def test_delete_backup_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 = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = {"name": "projects/sample1/locations/sample2/backups/sample3"} + sample_request = {"name": "projects/sample1/databases/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -12818,24 +13610,25 @@ def test_delete_backup_rest_flattened(): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + json_return_value = json_format.MessageToJson(return_value) response_value._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_backup(**mock_args) + client.import_documents(**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/*/backups/*}" % client.transport._host, + "%s/v1/{name=projects/*/databases/*}:importDocuments" + % client.transport._host, args[1], ) -def test_delete_backup_rest_flattened_error(transport: str = "rest"): +def test_import_documents_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -12844,13 +13637,13 @@ def test_delete_backup_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_backup( - firestore_admin.DeleteBackupRequest(), + client.import_documents( + firestore_admin.ImportDocumentsRequest(), name="name_value", ) -def test_restore_database_rest_use_cached_wrapped_rpc(): +def test_bulk_delete_documents_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: @@ -12864,7 +13657,10 @@ def test_restore_database_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert client._transport.restore_database in client._transport._wrapped_methods + assert ( + client._transport.bulk_delete_documents + in client._transport._wrapped_methods + ) # Replace cached wrapped function with mock mock_rpc = mock.Mock() @@ -12872,11 +13668,11 @@ def test_restore_database_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.restore_database + client._transport.bulk_delete_documents ] = mock_rpc request = {} - client.restore_database(request) + client.bulk_delete_documents(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 @@ -12885,22 +13681,20 @@ def test_restore_database_rest_use_cached_wrapped_rpc(): # subsequent calls should use the cached wrapper wrapper_fn.reset_mock() - client.restore_database(request) + client.bulk_delete_documents(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_restore_database_rest_required_fields( - request_type=firestore_admin.RestoreDatabaseRequest, +def test_bulk_delete_documents_rest_required_fields( + request_type=firestore_admin.BulkDeleteDocumentsRequest, ): transport_class = transports.FirestoreAdminRestTransport request_init = {} - request_init["parent"] = "" - request_init["database_id"] = "" - request_init["backup"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -12911,27 +13705,21 @@ def test_restore_database_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).restore_database._get_unset_required_fields(jsonified_request) + ).bulk_delete_documents._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - jsonified_request["parent"] = "parent_value" - jsonified_request["databaseId"] = "database_id_value" - jsonified_request["backup"] = "backup_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).restore_database._get_unset_required_fields(jsonified_request) + ).bulk_delete_documents._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" - assert "databaseId" in jsonified_request - assert jsonified_request["databaseId"] == "database_id_value" - assert "backup" in jsonified_request - assert jsonified_request["backup"] == "backup_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -12966,32 +13754,79 @@ def test_restore_database_rest_required_fields( req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.restore_database(request) + response = client.bulk_delete_documents(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_restore_database_rest_unset_required_fields(): +def test_bulk_delete_documents_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.restore_database._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(()) - & set( - ( - "parent", - "databaseId", - "backup", - ) + unset_fields = transport.bulk_delete_documents._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_bulk_delete_documents_rest_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "projects/sample1/databases/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._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.bulk_delete_documents(**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/*/databases/*}:bulkDeleteDocuments" + % client.transport._host, + args[1], ) + + +def test_bulk_delete_documents_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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.bulk_delete_documents( + firestore_admin.BulkDeleteDocumentsRequest(), + name="name_value", + ) -def test_create_backup_schedule_rest_use_cached_wrapped_rpc(): + +def test_create_database_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: @@ -13005,40 +13840,40 @@ def test_create_backup_schedule_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.create_backup_schedule - in client._transport._wrapped_methods - ) + assert client._transport.create_database 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_backup_schedule - ] = mock_rpc + client._transport._wrapped_methods[client._transport.create_database] = mock_rpc request = {} - client.create_backup_schedule(request) + client.create_database(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.create_backup_schedule(request) + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.create_database(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_backup_schedule_rest_required_fields( - request_type=firestore_admin.CreateBackupScheduleRequest, +def test_create_database_rest_required_fields( + request_type=firestore_admin.CreateDatabaseRequest, ): transport_class = transports.FirestoreAdminRestTransport request_init = {} request_init["parent"] = "" + request_init["database_id"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -13046,24 +13881,32 @@ def test_create_backup_schedule_rest_required_fields( ) # verify fields with default values are dropped + assert "databaseId" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_backup_schedule._get_unset_required_fields(jsonified_request) + ).create_database._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + assert "databaseId" in jsonified_request + assert jsonified_request["databaseId"] == request_init["database_id"] jsonified_request["parent"] = "parent_value" + jsonified_request["databaseId"] = "database_id_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_backup_schedule._get_unset_required_fields(jsonified_request) + ).create_database._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("database_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 "databaseId" in jsonified_request + assert jsonified_request["databaseId"] == "database_id_value" client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), @@ -13072,7 +13915,7 @@ def test_create_backup_schedule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = schedule.BackupSchedule() + return_value = operations_pb2.Operation(name="operations/spam") # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -13092,40 +13935,44 @@ def test_create_backup_schedule_rest_required_fields( response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = schedule.BackupSchedule.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup_schedule(request) + response = client.create_database(request) - expected_params = [("$alt", "json;enum-encoding=int")] + expected_params = [ + ( + "databaseId", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_create_backup_schedule_rest_unset_required_fields(): +def test_create_database_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_backup_schedule._get_unset_required_fields({}) + unset_fields = transport.create_database._get_unset_required_fields({}) assert set(unset_fields) == ( - set(()) + set(("databaseId",)) & set( ( "parent", - "backupSchedule", + "database", + "databaseId", ) ) ) -def test_create_backup_schedule_rest_flattened(): +def test_create_database_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13134,42 +13981,39 @@ def test_create_backup_schedule_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 = schedule.BackupSchedule() + return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/databases/sample2"} + sample_request = {"parent": "projects/sample1"} # get truthy value for each flattened field mock_args = dict( parent="parent_value", - backup_schedule=schedule.BackupSchedule(name="name_value"), + database=gfa_database.Database(name="name_value"), + database_id="database_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 = schedule.BackupSchedule.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_backup_schedule(**mock_args) + client.create_database(**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/*/databases/*}/backupSchedules" - % client.transport._host, - args[1], + "%s/v1/{parent=projects/*}/databases" % client.transport._host, args[1] ) -def test_create_backup_schedule_rest_flattened_error(transport: str = "rest"): +def test_create_database_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13178,14 +14022,15 @@ def test_create_backup_schedule_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_backup_schedule( - firestore_admin.CreateBackupScheduleRequest(), + client.create_database( + firestore_admin.CreateDatabaseRequest(), parent="parent_value", - backup_schedule=schedule.BackupSchedule(name="name_value"), + database=gfa_database.Database(name="name_value"), + database_id="database_id_value", ) -def test_get_backup_schedule_rest_use_cached_wrapped_rpc(): +def test_get_database_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: @@ -13199,34 +14044,30 @@ def test_get_backup_schedule_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.get_backup_schedule in client._transport._wrapped_methods - ) + assert client._transport.get_database 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_backup_schedule - ] = mock_rpc + client._transport._wrapped_methods[client._transport.get_database] = mock_rpc request = {} - client.get_backup_schedule(request) + client.get_database(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.get_backup_schedule(request) + client.get_database(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_backup_schedule_rest_required_fields( - request_type=firestore_admin.GetBackupScheduleRequest, +def test_get_database_rest_required_fields( + request_type=firestore_admin.GetDatabaseRequest, ): transport_class = transports.FirestoreAdminRestTransport @@ -13242,7 +14083,7 @@ def test_get_backup_schedule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_backup_schedule._get_unset_required_fields(jsonified_request) + ).get_database._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -13251,7 +14092,7 @@ def test_get_backup_schedule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_backup_schedule._get_unset_required_fields(jsonified_request) + ).get_database._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -13265,7 +14106,7 @@ def test_get_backup_schedule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = schedule.BackupSchedule() + return_value = database.Database() # 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 @@ -13286,30 +14127,30 @@ def test_get_backup_schedule_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = schedule.BackupSchedule.pb(return_value) + return_value = database.Database.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup_schedule(request) + response = client.get_database(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_backup_schedule_rest_unset_required_fields(): +def test_get_database_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_backup_schedule._get_unset_required_fields({}) + unset_fields = transport.get_database._get_unset_required_fields({}) assert set(unset_fields) == (set(()) & set(("name",))) -def test_get_backup_schedule_rest_flattened(): +def test_get_database_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13318,12 +14159,10 @@ def test_get_backup_schedule_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 = schedule.BackupSchedule() + return_value = database.Database() # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/databases/sample2/backupSchedules/sample3" - } + sample_request = {"name": "projects/sample1/databases/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -13335,26 +14174,24 @@ def test_get_backup_schedule_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = schedule.BackupSchedule.pb(return_value) + return_value = database.Database.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_backup_schedule(**mock_args) + client.get_database(**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/*/databases/*/backupSchedules/*}" - % client.transport._host, - args[1], + "%s/v1/{name=projects/*/databases/*}" % client.transport._host, args[1] ) -def test_get_backup_schedule_rest_flattened_error(transport: str = "rest"): +def test_get_database_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13363,13 +14200,13 @@ def test_get_backup_schedule_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_backup_schedule( - firestore_admin.GetBackupScheduleRequest(), + client.get_database( + firestore_admin.GetDatabaseRequest(), name="name_value", ) -def test_list_backup_schedules_rest_use_cached_wrapped_rpc(): +def test_list_databases_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: @@ -13383,35 +14220,30 @@ def test_list_backup_schedules_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.list_backup_schedules - in client._transport._wrapped_methods - ) + assert client._transport.list_databases 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_backup_schedules - ] = mock_rpc + client._transport._wrapped_methods[client._transport.list_databases] = mock_rpc request = {} - client.list_backup_schedules(request) + client.list_databases(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.list_backup_schedules(request) + client.list_databases(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_backup_schedules_rest_required_fields( - request_type=firestore_admin.ListBackupSchedulesRequest, +def test_list_databases_rest_required_fields( + request_type=firestore_admin.ListDatabasesRequest, ): transport_class = transports.FirestoreAdminRestTransport @@ -13427,7 +14259,7 @@ def test_list_backup_schedules_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_backup_schedules._get_unset_required_fields(jsonified_request) + ).list_databases._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -13436,7 +14268,9 @@ def test_list_backup_schedules_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).list_backup_schedules._get_unset_required_fields(jsonified_request) + ).list_databases._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("show_deleted",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -13450,7 +14284,7 @@ def test_list_backup_schedules_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListBackupSchedulesResponse() + return_value = firestore_admin.ListDatabasesResponse() # 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 @@ -13471,30 +14305,30 @@ def test_list_backup_schedules_rest_required_fields( response_value.status_code = 200 # Convert return value to protobuf type - return_value = firestore_admin.ListBackupSchedulesResponse.pb(return_value) + return_value = firestore_admin.ListDatabasesResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup_schedules(request) + response = client.list_databases(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_list_backup_schedules_rest_unset_required_fields(): +def test_list_databases_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.list_backup_schedules._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("parent",))) + unset_fields = transport.list_databases._get_unset_required_fields({}) + assert set(unset_fields) == (set(("showDeleted",)) & set(("parent",))) -def test_list_backup_schedules_rest_flattened(): +def test_list_databases_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13503,10 +14337,10 @@ def test_list_backup_schedules_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 = firestore_admin.ListBackupSchedulesResponse() + return_value = firestore_admin.ListDatabasesResponse() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/databases/sample2"} + sample_request = {"parent": "projects/sample1"} # get truthy value for each flattened field mock_args = dict( @@ -13518,26 +14352,24 @@ def test_list_backup_schedules_rest_flattened(): response_value = Response() response_value.status_code = 200 # Convert return value to protobuf type - return_value = firestore_admin.ListBackupSchedulesResponse.pb(return_value) + return_value = firestore_admin.ListDatabasesResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_backup_schedules(**mock_args) + client.list_databases(**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/*/databases/*}/backupSchedules" - % client.transport._host, - args[1], + "%s/v1/{parent=projects/*}/databases" % client.transport._host, args[1] ) -def test_list_backup_schedules_rest_flattened_error(transport: str = "rest"): +def test_list_databases_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13546,13 +14378,13 @@ def test_list_backup_schedules_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_backup_schedules( - firestore_admin.ListBackupSchedulesRequest(), + client.list_databases( + firestore_admin.ListDatabasesRequest(), parent="parent_value", ) -def test_update_backup_schedule_rest_use_cached_wrapped_rpc(): +def test_update_database_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: @@ -13566,35 +14398,34 @@ def test_update_backup_schedule_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.update_backup_schedule - in client._transport._wrapped_methods - ) + assert client._transport.update_database 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_backup_schedule - ] = mock_rpc + client._transport._wrapped_methods[client._transport.update_database] = mock_rpc request = {} - client.update_backup_schedule(request) + client.update_database(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_backup_schedule(request) + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.update_database(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_backup_schedule_rest_required_fields( - request_type=firestore_admin.UpdateBackupScheduleRequest, +def test_update_database_rest_required_fields( + request_type=firestore_admin.UpdateDatabaseRequest, ): transport_class = transports.FirestoreAdminRestTransport @@ -13609,14 +14440,14 @@ def test_update_backup_schedule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_backup_schedule._get_unset_required_fields(jsonified_request) + ).update_database._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_backup_schedule._get_unset_required_fields(jsonified_request) + ).update_database._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set(("update_mask",)) jsonified_request.update(unset_fields) @@ -13630,7 +14461,7 @@ def test_update_backup_schedule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = schedule.BackupSchedule() + return_value = operations_pb2.Operation(name="operations/spam") # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -13650,32 +14481,29 @@ def test_update_backup_schedule_rest_required_fields( response_value = Response() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = schedule.BackupSchedule.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup_schedule(request) + response = client.update_database(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_backup_schedule_rest_unset_required_fields(): +def test_update_database_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_backup_schedule._get_unset_required_fields({}) - assert set(unset_fields) == (set(("updateMask",)) & set(("backupSchedule",))) + unset_fields = transport.update_database._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("database",))) -def test_update_backup_schedule_rest_flattened(): +def test_update_database_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13684,18 +14512,14 @@ def test_update_backup_schedule_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 = schedule.BackupSchedule() + return_value = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = { - "backup_schedule": { - "name": "projects/sample1/databases/sample2/backupSchedules/sample3" - } - } + sample_request = {"database": {"name": "projects/sample1/databases/sample2"}} # get truthy value for each flattened field mock_args = dict( - backup_schedule=schedule.BackupSchedule(name="name_value"), + database=gfa_database.Database(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -13703,27 +14527,24 @@ def test_update_backup_schedule_rest_flattened(): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - # Convert return value to protobuf type - return_value = schedule.BackupSchedule.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value._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_backup_schedule(**mock_args) + client.update_database(**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/{backup_schedule.name=projects/*/databases/*/backupSchedules/*}" - % client.transport._host, + "%s/v1/{database.name=projects/*/databases/*}" % client.transport._host, args[1], ) -def test_update_backup_schedule_rest_flattened_error(transport: str = "rest"): +def test_update_database_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13732,14 +14553,14 @@ def test_update_backup_schedule_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_backup_schedule( - firestore_admin.UpdateBackupScheduleRequest(), - backup_schedule=schedule.BackupSchedule(name="name_value"), + client.update_database( + firestore_admin.UpdateDatabaseRequest(), + database=gfa_database.Database(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_delete_backup_schedule_rest_use_cached_wrapped_rpc(): +def test_delete_database_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: @@ -13753,35 +14574,34 @@ def test_delete_backup_schedule_rest_use_cached_wrapped_rpc(): wrapper_fn.reset_mock() # Ensure method has been cached - assert ( - client._transport.delete_backup_schedule - in client._transport._wrapped_methods - ) + assert client._transport.delete_database 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_backup_schedule - ] = mock_rpc + client._transport._wrapped_methods[client._transport.delete_database] = mock_rpc request = {} - client.delete_backup_schedule(request) + client.delete_database(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.delete_backup_schedule(request) + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.delete_database(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_backup_schedule_rest_required_fields( - request_type=firestore_admin.DeleteBackupScheduleRequest, +def test_delete_database_rest_required_fields( + request_type=firestore_admin.DeleteDatabaseRequest, ): transport_class = transports.FirestoreAdminRestTransport @@ -13797,7 +14617,7 @@ def test_delete_backup_schedule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_backup_schedule._get_unset_required_fields(jsonified_request) + ).delete_database._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present @@ -13806,7 +14626,9 @@ def test_delete_backup_schedule_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).delete_backup_schedule._get_unset_required_fields(jsonified_request) + ).delete_database._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("etag",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone @@ -13820,7 +14642,7 @@ def test_delete_backup_schedule_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = None + return_value = operations_pb2.Operation(name="operations/spam") # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -13839,29 +14661,29 @@ def test_delete_backup_schedule_rest_required_fields( response_value = Response() response_value.status_code = 200 - json_return_value = "" + json_return_value = json_format.MessageToJson(return_value) response_value._content = json_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_backup_schedule(request) + response = client.delete_database(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_delete_backup_schedule_rest_unset_required_fields(): +def test_delete_database_rest_unset_required_fields(): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.delete_backup_schedule._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.delete_database._get_unset_required_fields({}) + assert set(unset_fields) == (set(("etag",)) & set(("name",))) -def test_delete_backup_schedule_rest_flattened(): +def test_delete_database_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -13870,12 +14692,10 @@ def test_delete_backup_schedule_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 = operations_pb2.Operation(name="operations/spam") # get arguments that satisfy an http rule for this method - sample_request = { - "name": "projects/sample1/databases/sample2/backupSchedules/sample3" - } + sample_request = {"name": "projects/sample1/databases/sample2"} # get truthy value for each flattened field mock_args = dict( @@ -13886,25 +14706,23 @@ def test_delete_backup_schedule_rest_flattened(): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - json_return_value = "" + json_return_value = json_format.MessageToJson(return_value) response_value._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_backup_schedule(**mock_args) + client.delete_database(**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/*/databases/*/backupSchedules/*}" - % client.transport._host, - args[1], + "%s/v1/{name=projects/*/databases/*}" % client.transport._host, args[1] ) -def test_delete_backup_schedule_rest_flattened_error(transport: str = "rest"): +def test_delete_database_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -13913,1306 +14731,5285 @@ def test_delete_backup_schedule_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_backup_schedule( - firestore_admin.DeleteBackupScheduleRequest(), + client.delete_database( + firestore_admin.DeleteDatabaseRequest(), name="name_value", ) -def test_credentials_transport_error(): - # It is an error to provide credentials and a transport instance. - transport = transports.FirestoreAdminGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): +def test_create_user_creds_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 = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="rest", ) - # It is an error to provide a credentials file and a transport instance. - transport = transports.FirestoreAdminGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = FirestoreAdminClient( - client_options={"credentials_file": "credentials.json"}, - 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 transport instance. - transport = transports.FirestoreAdminGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - options = client_options.ClientOptions() - options.api_key = "api_key" - with pytest.raises(ValueError): - client = FirestoreAdminClient( - client_options=options, - transport=transport, - ) + # Ensure method has been cached + assert client._transport.create_user_creds in client._transport._wrapped_methods - # 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 = FirestoreAdminClient( - client_options=options, credentials=ga_credentials.AnonymousCredentials() + # 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_user_creds + ] = mock_rpc - # It is an error to provide scopes and a transport instance. - transport = transports.FirestoreAdminGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = FirestoreAdminClient( - client_options={"scopes": ["1", "2"]}, - transport=transport, - ) + request = {} + client.create_user_creds(request) + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 -def test_transport_instance(): - # A client may be instantiated with a custom transport instance. - transport = transports.FirestoreAdminGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - client = FirestoreAdminClient(transport=transport) - assert client.transport is transport + client.create_user_creds(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_transport_get_channel(): - # A client may be instantiated with a custom transport instance. - transport = transports.FirestoreAdminGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - channel = transport.grpc_channel - assert channel - transport = transports.FirestoreAdminGrpcAsyncIOTransport( - credentials=ga_credentials.AnonymousCredentials(), +def test_create_user_creds_rest_required_fields( + request_type=firestore_admin.CreateUserCredsRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + request_init = {} + request_init["parent"] = "" + request_init["user_creds_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) ) - channel = transport.grpc_channel - assert channel + # verify fields with default values are dropped + assert "userCredsId" not in jsonified_request -@pytest.mark.parametrize( - "transport_class", - [ - transports.FirestoreAdminGrpcTransport, - transports.FirestoreAdminGrpcAsyncIOTransport, - transports.FirestoreAdminRestTransport, - ], -) -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() + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_user_creds._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + # verify required fields with default values are now present + assert "userCredsId" in jsonified_request + assert jsonified_request["userCredsId"] == request_init["user_creds_id"] -def test_transport_kind_grpc(): - transport = FirestoreAdminClient.get_transport_class("grpc")( + jsonified_request["parent"] = "parent_value" + jsonified_request["userCredsId"] = "user_creds_id_value" + + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ) - assert transport.kind == "grpc" + ).create_user_creds._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("user_creds_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 "userCredsId" in jsonified_request + assert jsonified_request["userCredsId"] == "user_creds_id_value" -def test_initialize_client_w_grpc(): - client = FirestoreAdminClient( - 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_index_empty_call_grpc(): client = FirestoreAdminClient( 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_index), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.create_index(request=None) + # Designate an appropriate value for the returned response. + return_value = gfa_user_creds.UserCreds() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.CreateIndexRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = gfa_user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_list_indexes_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + response = client.create_user_creds(request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_indexes), "__call__") as call: - call.return_value = firestore_admin.ListIndexesResponse() - client.list_indexes(request=None) + expected_params = [ + ( + "userCredsId", + "", + ), + ("$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 = firestore_admin.ListIndexesRequest() - assert args[0] == request_msg +def test_create_user_creds_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.create_user_creds._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("userCredsId",)) + & set( + ( + "parent", + "userCreds", + "userCredsId", + ) + ) + ) -# This 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_index_empty_call_grpc(): + +def test_create_user_creds_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_index), "__call__") as call: - call.return_value = index.Index() - client.get_index(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetIndexRequest() - - assert args[0] == request_msg + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gfa_user_creds.UserCreds() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/databases/sample2"} -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_delete_index_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + user_creds=gfa_user_creds.UserCreds(name="name_value"), + user_creds_id="user_creds_id_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_index), "__call__") as call: - call.return_value = None - client.delete_index(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 = gfa_user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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 = firestore_admin.DeleteIndexRequest() + client.create_user_creds(**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/*/databases/*}/userCreds" % client.transport._host, + args[1], + ) -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_get_field_empty_call_grpc(): +def test_create_user_creds_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_field), "__call__") as call: - call.return_value = field.Field() - client.get_field(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_user_creds( + firestore_admin.CreateUserCredsRequest(), + parent="parent_value", + user_creds=gfa_user_creds.UserCreds(name="name_value"), + user_creds_id="user_creds_id_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetFieldRequest() - assert args[0] == request_msg +def test_get_user_creds_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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_update_field_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert client._transport.get_user_creds in client._transport._wrapped_methods - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_field), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.update_field(request=None) + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.get_user_creds] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.UpdateFieldRequest() + request = {} + client.get_user_creds(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.get_user_creds(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_fields_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_fields), "__call__") as call: - call.return_value = firestore_admin.ListFieldsResponse() - client.list_fields(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ListFieldsRequest() +def test_get_user_creds_rest_required_fields( + request_type=firestore_admin.GetUserCredsRequest, +): + transport_class = transports.FirestoreAdminRestTransport - 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_export_documents_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_user_creds._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.export_documents), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.export_documents(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 = firestore_admin.ExportDocumentsRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_user_creds._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_import_documents_empty_call_grpc(): client = FirestoreAdminClient( 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.import_documents), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.import_documents(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ImportDocumentsRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + response_value = Response() + response_value.status_code = 200 -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_bulk_delete_documents_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = user_creds.UserCreds.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.bulk_delete_documents), "__call__" - ) as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.bulk_delete_documents(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 = firestore_admin.BulkDeleteDocumentsRequest() + response = client.get_user_creds(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_create_database_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_get_user_creds_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_database), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.create_database(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.CreateDatabaseRequest() - - assert args[0] == request_msg + unset_fields = transport.get_user_creds._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_get_database_empty_call_grpc(): +def test_get_user_creds_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_database), "__call__") as call: - call.return_value = database.Database() - client.get_database(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetDatabaseRequest() - - assert args[0] == request_msg + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/databases/sample2/userCreds/sample3" + } -# This 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_databases_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_databases), "__call__") as call: - call.return_value = firestore_admin.ListDatabasesResponse() - client.list_databases(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 = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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 = firestore_admin.ListDatabasesRequest() + client.get_user_creds(**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/{name=projects/*/databases/*/userCreds/*}" % 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_update_database_empty_call_grpc(): +def test_get_user_creds_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_database), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.update_database(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_user_creds( + firestore_admin.GetUserCredsRequest(), + name="name_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.UpdateDatabaseRequest() - assert args[0] == request_msg +def test_list_user_creds_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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_delete_database_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert client._transport.list_user_creds in client._transport._wrapped_methods - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_database), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.delete_database(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_user_creds] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.DeleteDatabaseRequest() + request = {} + client.list_user_creds(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.list_user_creds(request) -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_get_backup_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: - call.return_value = backup.Backup() - client.get_backup(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetBackupRequest() +def test_list_user_creds_rest_required_fields( + request_type=firestore_admin.ListUserCredsRequest, +): + transport_class = transports.FirestoreAdminRestTransport - assert args[0] == request_msg + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + # verify fields with default values are dropped -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_list_backups_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_user_creds._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: - call.return_value = firestore_admin.ListBackupsResponse() - client.list_backups(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 = firestore_admin.ListBackupsRequest() + jsonified_request["parent"] = "parent_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_user_creds._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_delete_backup_empty_call_grpc(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) + request = request_type(**request_init) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: - call.return_value = None - client.delete_backup(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.DeleteBackupRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = firestore_admin.ListUserCredsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + response_value = Response() + response_value.status_code = 200 -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_restore_database_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Convert return value to protobuf type + return_value = firestore_admin.ListUserCredsResponse.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.restore_database), "__call__") as call: - call.return_value = operations_pb2.Operation(name="operations/op") - client.restore_database(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 = firestore_admin.RestoreDatabaseRequest() + response = client.list_user_creds(request) - assert args[0] == request_msg + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_create_backup_schedule_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", +def test_list_user_creds_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" - ) as call: - call.return_value = schedule.BackupSchedule() - client.create_backup_schedule(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.CreateBackupScheduleRequest() - - assert args[0] == request_msg + unset_fields = transport.list_user_creds._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("parent",))) -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_get_backup_schedule_empty_call_grpc(): +def test_list_user_creds_rest_flattened(): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" - ) as call: - call.return_value = schedule.BackupSchedule() - client.get_backup_schedule(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetBackupScheduleRequest() - - assert args[0] == request_msg + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = firestore_admin.ListUserCredsResponse() + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/databases/sample2"} -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_list_backup_schedules_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" - ) as call: - call.return_value = firestore_admin.ListBackupSchedulesResponse() - client.list_backup_schedules(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 = firestore_admin.ListUserCredsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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 = firestore_admin.ListBackupSchedulesRequest() + client.list_user_creds(**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/*/databases/*}/userCreds" % 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_update_backup_schedule_empty_call_grpc(): +def test_list_user_creds_rest_flattened_error(transport: str = "rest"): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: - call.return_value = schedule.BackupSchedule() - client.update_backup_schedule(request=None) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_user_creds( + firestore_admin.ListUserCredsRequest(), + parent="parent_value", + ) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.UpdateBackupScheduleRequest() - assert args[0] == request_msg +def test_enable_user_creds_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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() -# This test is a coverage failsafe to make sure that totally empty calls, -# i.e. request == None and no flattened fields passed, work. -def test_delete_backup_schedule_empty_call_grpc(): - client = FirestoreAdminClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="grpc", - ) + # Ensure method has been cached + assert client._transport.enable_user_creds in client._transport._wrapped_methods - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: - call.return_value = None - client.delete_backup_schedule(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.enable_user_creds + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.DeleteBackupScheduleRequest() + request = {} + client.enable_user_creds(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.enable_user_creds(request) -def test_transport_kind_grpc_asyncio(): - transport = FirestoreAdminAsyncClient.get_transport_class("grpc_asyncio")( - credentials=async_anonymous_credentials() - ) - assert transport.kind == "grpc_asyncio" + # 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 = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), transport="grpc_asyncio" +def test_enable_user_creds_rest_required_fields( + request_type=firestore_admin.EnableUserCredsRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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) ) - assert client is not None + # 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. -@pytest.mark.asyncio -async def test_create_index_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).enable_user_creds._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.create_index), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") - ) - await client.create_index(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 = firestore_admin.CreateIndexRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).enable_user_creds._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. -@pytest.mark.asyncio -async def test_list_indexes_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + client = FirestoreAdminClient( + 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.list_indexes), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListIndexesResponse( - next_page_token="next_page_token_value", - ) - ) - await client.list_indexes(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ListIndexesRequest() - - assert args[0] == request_msg + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + # 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. -@pytest.mark.asyncio -async def test_get_index_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # Convert return value to protobuf type + return_value = user_creds.UserCreds.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.get_index), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - index.Index( - name="name_value", - query_scope=index.Index.QueryScope.COLLECTION, - api_scope=index.Index.ApiScope.DATASTORE_MODE_API, - state=index.Index.State.CREATING, - ) - ) - await client.get_index(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 = firestore_admin.GetIndexRequest() + response = client.enable_user_creds(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_delete_index_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_enable_user_creds_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_index), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_index(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.DeleteIndexRequest() - - assert args[0] == request_msg + unset_fields = transport.enable_user_creds._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. -@pytest.mark.asyncio -async def test_get_field_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_enable_user_creds_rest_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_field), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - field.Field( - name="name_value", - ) - ) - await client.get_field(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 = user_creds.UserCreds() - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetFieldRequest() + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/databases/sample2/userCreds/sample3" + } - 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 + # Convert return value to protobuf type + return_value = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_update_field_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + client.enable_user_creds(**mock_args) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_field), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + # 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/*/databases/*/userCreds/*}:enable" + % client.transport._host, + args[1], ) - await client.update_field(request=None) - - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.UpdateFieldRequest() - - assert args[0] == request_msg -# This test is a coverage 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_fields_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_enable_user_creds_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_fields), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListFieldsResponse( - 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.enable_user_creds( + firestore_admin.EnableUserCredsRequest(), + name="name_value", ) - await client.list_fields(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ListFieldsRequest() - assert args[0] == request_msg +def test_disable_user_creds_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 = FirestoreAdminClient( + 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. -@pytest.mark.asyncio -async def test_export_documents_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # Ensure method has been cached + assert ( + client._transport.disable_user_creds in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.export_documents), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + # 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. ) - await client.export_documents(request=None) + client._transport._wrapped_methods[ + client._transport.disable_user_creds + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ExportDocumentsRequest() + request = {} + client.disable_user_creds(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.disable_user_creds(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_import_documents_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # 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.import_documents), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") - ) - await client.import_documents(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ImportDocumentsRequest() +def test_disable_user_creds_rest_required_fields( + request_type=firestore_admin.DisableUserCredsRequest, +): + transport_class = transports.FirestoreAdminRestTransport - 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. -@pytest.mark.asyncio -async def test_bulk_delete_documents_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).disable_user_creds._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.bulk_delete_documents), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") - ) - await client.bulk_delete_documents(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 = firestore_admin.BulkDeleteDocumentsRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).disable_user_creds._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. -@pytest.mark.asyncio -async def test_create_database_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + client = FirestoreAdminClient( + 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.create_database), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") - ) - await client.create_database(request=None) + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.CreateDatabaseRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_get_database_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + response = client.disable_user_creds(request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_database), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - database.Database( - name="name_value", - uid="uid_value", - location_id="location_id_value", - type_=database.Database.DatabaseType.FIRESTORE_NATIVE, - concurrency_mode=database.Database.ConcurrencyMode.OPTIMISTIC, - point_in_time_recovery_enablement=database.Database.PointInTimeRecoveryEnablement.POINT_IN_TIME_RECOVERY_ENABLED, - app_engine_integration_mode=database.Database.AppEngineIntegrationMode.ENABLED, - key_prefix="key_prefix_value", - delete_protection_state=database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED, - previous_id="previous_id_value", - etag="etag_value", - ) - ) - await client.get_database(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 = firestore_admin.GetDatabaseRequest() - assert args[0] == request_msg +def test_disable_user_creds_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.disable_user_creds._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. -@pytest.mark.asyncio -async def test_list_databases_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + +def test_disable_user_creds_rest_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_databases), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListDatabasesResponse( - unreachable=["unreachable_value"], - ) + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/databases/sample2/userCreds/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", ) - await client.list_databases(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 = firestore_admin.ListDatabasesRequest() + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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.disable_user_creds(**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/*/databases/*/userCreds/*}:disable" + % 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_update_database_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + +def test_disable_user_creds_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.update_database), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.disable_user_creds( + firestore_admin.DisableUserCredsRequest(), + name="name_value", ) - await client.update_database(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.UpdateDatabaseRequest() - assert args[0] == request_msg +def test_reset_user_password_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 = FirestoreAdminClient( + 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. -@pytest.mark.asyncio -async def test_delete_database_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # Ensure method has been cached + assert ( + client._transport.reset_user_password in client._transport._wrapped_methods + ) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.delete_database), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") + # 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. ) - await client.delete_database(request=None) + client._transport._wrapped_methods[ + client._transport.reset_user_password + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.DeleteDatabaseRequest() + request = {} + client.reset_user_password(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.reset_user_password(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_get_backup_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.get_backup), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - backup.Backup( - name="name_value", - database="database_value", - database_uid="database_uid_value", - state=backup.Backup.State.CREATING, - ) - ) - await client.get_backup(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetBackupRequest() +def test_reset_user_password_rest_required_fields( + request_type=firestore_admin.ResetUserPasswordRequest, +): + transport_class = transports.FirestoreAdminRestTransport - 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. -@pytest.mark.asyncio -async def test_list_backups_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).reset_user_password._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.list_backups), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupsResponse( - unreachable=["unreachable_value"], - ) - ) - await client.list_backups(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 = firestore_admin.ListBackupsRequest() + jsonified_request["name"] = "name_value" - assert args[0] == request_msg + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).reset_user_password._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. -@pytest.mark.asyncio -async def test_delete_backup_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + client = FirestoreAdminClient( + 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.delete_backup), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_backup(request=None) + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.DeleteBackupRequest() + response_value = Response() + response_value.status_code = 200 - assert args[0] == request_msg + # Convert return value to protobuf type + return_value = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_restore_database_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + response = client.reset_user_password(request) - # Mock the actual call, and fake the request. - with mock.patch.object(type(client.transport.restore_database), "__call__") as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - operations_pb2.Operation(name="operations/spam") - ) - await client.restore_database(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 = firestore_admin.RestoreDatabaseRequest() - assert args[0] == request_msg +def test_reset_user_password_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + unset_fields = transport.reset_user_password._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. -@pytest.mark.asyncio -async def test_create_backup_schedule_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + +def test_reset_user_password_rest_flattened(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.create_backup_schedule), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule( - name="name_value", - ) + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/databases/sample2/userCreds/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", ) - await client.create_backup_schedule(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 = firestore_admin.CreateBackupScheduleRequest() + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + # Convert return value to protobuf type + return_value = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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.reset_user_password(**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/*/databases/*/userCreds/*}:resetPassword" + % 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_get_backup_schedule_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", +def test_reset_user_password_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.get_backup_schedule), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule( - name="name_value", - ) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.reset_user_password( + firestore_admin.ResetUserPasswordRequest(), + name="name_value", ) - await client.get_backup_schedule(request=None) - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.GetBackupScheduleRequest() - assert args[0] == request_msg +def test_delete_user_creds_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 = FirestoreAdminClient( + 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. -@pytest.mark.asyncio -async def test_list_backup_schedules_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", - ) + # Ensure method has been cached + assert client._transport.delete_user_creds in client._transport._wrapped_methods - # Mock the actual call, and fake the request. - with mock.patch.object( - type(client.transport.list_backup_schedules), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - firestore_admin.ListBackupSchedulesResponse() + # 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. ) - await client.list_backup_schedules(request=None) + client._transport._wrapped_methods[ + client._transport.delete_user_creds + ] = mock_rpc - # Establish that the underlying stub method was called. - call.assert_called() - _, args, _ = call.mock_calls[0] - request_msg = firestore_admin.ListBackupSchedulesRequest() + request = {} + client.delete_user_creds(request) - assert args[0] == request_msg + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + client.delete_user_creds(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_update_backup_schedule_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_delete_user_creds_rest_required_fields( + request_type=firestore_admin.DeleteUserCredsRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_user_creds._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_user_creds._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 = FirestoreAdminClient( + 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_user_creds(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_user_creds_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_user_creds._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_user_creds_rest_flattened(): + client = FirestoreAdminClient( + 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/databases/sample2/userCreds/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_user_creds(**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/*/databases/*/userCreds/*}" % client.transport._host, + args[1], + ) + + +def test_delete_user_creds_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_user_creds( + firestore_admin.DeleteUserCredsRequest(), + name="name_value", + ) + + +def test_get_backup_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 = FirestoreAdminClient( + 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_backup 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_backup] = mock_rpc + + request = {} + client.get_backup(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_backup(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_backup_rest_required_fields(request_type=firestore_admin.GetBackupRequest): + transport_class = transports.FirestoreAdminRestTransport + + 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_backup._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_backup._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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = backup.Backup() + # 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 = backup.Backup.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_backup(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_backup_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_backup._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_backup_rest_flattened(): + client = FirestoreAdminClient( + 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 = backup.Backup() + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "projects/sample1/locations/sample2/backups/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 = backup.Backup.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_backup(**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/*/backups/*}" % client.transport._host, + args[1], + ) + + +def test_get_backup_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup( + firestore_admin.GetBackupRequest(), + name="name_value", + ) + + +def test_list_backups_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 = FirestoreAdminClient( + 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_backups 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_backups] = mock_rpc + + request = {} + client.list_backups(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_backups(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_backups_rest_required_fields( + request_type=firestore_admin.ListBackupsRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_backups._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_backups._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("filter",)) + 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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = firestore_admin.ListBackupsResponse() + # 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 = firestore_admin.ListBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_backups(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_backups_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_backups._get_unset_required_fields({}) + assert set(unset_fields) == (set(("filter",)) & set(("parent",))) + + +def test_list_backups_rest_flattened(): + client = FirestoreAdminClient( + 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 = firestore_admin.ListBackupsResponse() + + # 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 = firestore_admin.ListBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_backups(**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/*}/backups" % client.transport._host, + args[1], + ) + + +def test_list_backups_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backups( + firestore_admin.ListBackupsRequest(), + parent="parent_value", + ) + + +def test_delete_backup_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 = FirestoreAdminClient( + 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_backup 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_backup] = mock_rpc + + request = {} + client.delete_backup(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_backup(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_backup_rest_required_fields( + request_type=firestore_admin.DeleteBackupRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_backup._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_backup._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 = FirestoreAdminClient( + 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_backup(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_backup_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_backup._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_backup_rest_flattened(): + client = FirestoreAdminClient( + 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/backups/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_backup(**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/*/backups/*}" % client.transport._host, + args[1], + ) + + +def test_delete_backup_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup( + firestore_admin.DeleteBackupRequest(), + name="name_value", + ) + + +def test_restore_database_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 = FirestoreAdminClient( + 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.restore_database 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.restore_database + ] = mock_rpc + + request = {} + client.restore_database(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + # Operation methods build a cached wrapper on first rpc call + # subsequent calls should use the cached wrapper + wrapper_fn.reset_mock() + + client.restore_database(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_restore_database_rest_required_fields( + request_type=firestore_admin.RestoreDatabaseRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + request_init = {} + request_init["parent"] = "" + request_init["database_id"] = "" + request_init["backup"] = "" + 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() + ).restore_database._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + jsonified_request["databaseId"] = "database_id_value" + jsonified_request["backup"] = "backup_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).restore_database._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "databaseId" in jsonified_request + assert jsonified_request["databaseId"] == "database_id_value" + assert "backup" in jsonified_request + assert jsonified_request["backup"] == "backup_value" + + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + response = client.restore_database(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_restore_database_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.restore_database._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "databaseId", + "backup", + ) + ) + ) + + +def test_create_backup_schedule_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 = FirestoreAdminClient( + 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_backup_schedule + 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_backup_schedule + ] = mock_rpc + + request = {} + client.create_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.create_backup_schedule(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_backup_schedule_rest_required_fields( + request_type=firestore_admin.CreateBackupScheduleRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_backup_schedule._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_backup_schedule._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = schedule.BackupSchedule() + # 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 = schedule.BackupSchedule.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_backup_schedule(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_backup_schedule_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_backup_schedule._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(()) + & set( + ( + "parent", + "backupSchedule", + ) + ) + ) + + +def test_create_backup_schedule_rest_flattened(): + client = FirestoreAdminClient( + 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 = schedule.BackupSchedule() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/databases/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + backup_schedule=schedule.BackupSchedule(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 = schedule.BackupSchedule.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_backup_schedule(**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/*/databases/*}/backupSchedules" + % client.transport._host, + args[1], + ) + + +def test_create_backup_schedule_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup_schedule( + firestore_admin.CreateBackupScheduleRequest(), + parent="parent_value", + backup_schedule=schedule.BackupSchedule(name="name_value"), + ) + + +def test_get_backup_schedule_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 = FirestoreAdminClient( + 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_backup_schedule 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_backup_schedule + ] = mock_rpc + + request = {} + client.get_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.get_backup_schedule(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_backup_schedule_rest_required_fields( + request_type=firestore_admin.GetBackupScheduleRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_backup_schedule._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_backup_schedule._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 = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = schedule.BackupSchedule() + # 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 = schedule.BackupSchedule.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_backup_schedule(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_backup_schedule_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_backup_schedule._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_get_backup_schedule_rest_flattened(): + client = FirestoreAdminClient( + 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 = schedule.BackupSchedule() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/databases/sample2/backupSchedules/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 = schedule.BackupSchedule.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_backup_schedule(**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/*/databases/*/backupSchedules/*}" + % client.transport._host, + args[1], + ) + + +def test_get_backup_schedule_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup_schedule( + firestore_admin.GetBackupScheduleRequest(), + name="name_value", + ) + + +def test_list_backup_schedules_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 = FirestoreAdminClient( + 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_backup_schedules + 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_backup_schedules + ] = mock_rpc + + request = {} + client.list_backup_schedules(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.list_backup_schedules(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_backup_schedules_rest_required_fields( + request_type=firestore_admin.ListBackupSchedulesRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_backup_schedules._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_backup_schedules._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = firestore_admin.ListBackupSchedulesResponse() + # 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 = firestore_admin.ListBackupSchedulesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_backup_schedules(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_backup_schedules_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_backup_schedules._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("parent",))) + + +def test_list_backup_schedules_rest_flattened(): + client = FirestoreAdminClient( + 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 = firestore_admin.ListBackupSchedulesResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/databases/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 = firestore_admin.ListBackupSchedulesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_backup_schedules(**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/*/databases/*}/backupSchedules" + % client.transport._host, + args[1], + ) + + +def test_list_backup_schedules_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup_schedules( + firestore_admin.ListBackupSchedulesRequest(), + parent="parent_value", + ) + + +def test_update_backup_schedule_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 = FirestoreAdminClient( + 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_backup_schedule + 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_backup_schedule + ] = mock_rpc + + request = {} + client.update_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.update_backup_schedule(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_backup_schedule_rest_required_fields( + request_type=firestore_admin.UpdateBackupScheduleRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_backup_schedule._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_backup_schedule._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = schedule.BackupSchedule() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "patch", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = schedule.BackupSchedule.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_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_backup_schedule(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_backup_schedule_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_backup_schedule._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("backupSchedule",))) + + +def test_update_backup_schedule_rest_flattened(): + client = FirestoreAdminClient( + 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 = schedule.BackupSchedule() + + # get arguments that satisfy an http rule for this method + sample_request = { + "backup_schedule": { + "name": "projects/sample1/databases/sample2/backupSchedules/sample3" + } + } + + # get truthy value for each flattened field + mock_args = dict( + backup_schedule=schedule.BackupSchedule(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 = schedule.BackupSchedule.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value._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_backup_schedule(**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/{backup_schedule.name=projects/*/databases/*/backupSchedules/*}" + % client.transport._host, + args[1], + ) + + +def test_update_backup_schedule_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup_schedule( + firestore_admin.UpdateBackupScheduleRequest(), + backup_schedule=schedule.BackupSchedule(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_delete_backup_schedule_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 = FirestoreAdminClient( + 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_backup_schedule + 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_backup_schedule + ] = mock_rpc + + request = {} + client.delete_backup_schedule(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_backup_schedule(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_backup_schedule_rest_required_fields( + request_type=firestore_admin.DeleteBackupScheduleRequest, +): + transport_class = transports.FirestoreAdminRestTransport + + 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_backup_schedule._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_backup_schedule._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 = FirestoreAdminClient( + 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_backup_schedule(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_backup_schedule_rest_unset_required_fields(): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_backup_schedule._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +def test_delete_backup_schedule_rest_flattened(): + client = FirestoreAdminClient( + 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/databases/sample2/backupSchedules/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_backup_schedule(**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/*/databases/*/backupSchedules/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_backup_schedule_rest_flattened_error(transport: str = "rest"): + client = FirestoreAdminClient( + 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_backup_schedule( + firestore_admin.DeleteBackupScheduleRequest(), + name="name_value", + ) + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.FirestoreAdminGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.FirestoreAdminGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = FirestoreAdminClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide an api_key and a transport instance. + transport = transports.FirestoreAdminGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = FirestoreAdminClient( + 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 = FirestoreAdminClient( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.FirestoreAdminGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = FirestoreAdminClient( + client_options={"scopes": ["1", "2"]}, + transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.FirestoreAdminGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = FirestoreAdminClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.FirestoreAdminGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.FirestoreAdminGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.FirestoreAdminGrpcTransport, + transports.FirestoreAdminGrpcAsyncIOTransport, + transports.FirestoreAdminRestTransport, + ], +) +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 = FirestoreAdminClient.get_transport_class("grpc")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "grpc" + + +def test_initialize_client_w_grpc(): + client = FirestoreAdminClient( + 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_index_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_index), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.create_index(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateIndexRequest() + + assert args[0] == request_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_indexes_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_indexes), "__call__") as call: + call.return_value = firestore_admin.ListIndexesResponse() + client.list_indexes(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListIndexesRequest() + + assert args[0] == request_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_index_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_index), "__call__") as call: + call.return_value = index.Index() + client.get_index(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetIndexRequest() + + assert args[0] == request_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_index_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_index), "__call__") as call: + call.return_value = None + client.delete_index(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteIndexRequest() + + assert args[0] == request_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_field_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_field), "__call__") as call: + call.return_value = field.Field() + client.get_field(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetFieldRequest() + + assert args[0] == request_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_field_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_field), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.update_field(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.UpdateFieldRequest() + + assert args[0] == request_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_fields_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_fields), "__call__") as call: + call.return_value = firestore_admin.ListFieldsResponse() + client.list_fields(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListFieldsRequest() + + assert args[0] == request_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_export_documents_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.export_documents), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.export_documents(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ExportDocumentsRequest() + + assert args[0] == request_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_import_documents_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.import_documents), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.import_documents(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ImportDocumentsRequest() + + assert args[0] == request_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_bulk_delete_documents_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.bulk_delete_documents), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.bulk_delete_documents(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.BulkDeleteDocumentsRequest() + + assert args[0] == request_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_database_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_database), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.create_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateDatabaseRequest() + + assert args[0] == request_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_database_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_database), "__call__") as call: + call.return_value = database.Database() + client.get_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetDatabaseRequest() + + assert args[0] == request_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_databases_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_databases), "__call__") as call: + call.return_value = firestore_admin.ListDatabasesResponse() + client.list_databases(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListDatabasesRequest() + + assert args[0] == request_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_database_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_database), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.update_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.UpdateDatabaseRequest() + + assert args[0] == request_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_database_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_database), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.delete_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteDatabaseRequest() + + assert args[0] == request_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_user_creds_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: + call.return_value = gfa_user_creds.UserCreds() + client.create_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateUserCredsRequest() + + assert args[0] == request_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_user_creds_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: + call.return_value = user_creds.UserCreds() + client.get_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetUserCredsRequest() + + assert args[0] == request_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_user_creds_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: + call.return_value = firestore_admin.ListUserCredsResponse() + client.list_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListUserCredsRequest() + + assert args[0] == request_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_enable_user_creds_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: + call.return_value = user_creds.UserCreds() + client.enable_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.EnableUserCredsRequest() + + assert args[0] == request_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_disable_user_creds_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.disable_user_creds), "__call__" + ) as call: + call.return_value = user_creds.UserCreds() + client.disable_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DisableUserCredsRequest() + + assert args[0] == request_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_reset_user_password_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.reset_user_password), "__call__" + ) as call: + call.return_value = user_creds.UserCreds() + client.reset_user_password(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ResetUserPasswordRequest() + + assert args[0] == request_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_user_creds_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_user_creds), "__call__" + ) as call: + call.return_value = None + client.delete_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteUserCredsRequest() + + assert args[0] == request_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_backup_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + call.return_value = backup.Backup() + client.get_backup(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetBackupRequest() + + assert args[0] == request_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_backups_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + call.return_value = firestore_admin.ListBackupsResponse() + client.list_backups(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListBackupsRequest() + + assert args[0] == request_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_backup_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + call.return_value = None + client.delete_backup(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteBackupRequest() + + assert args[0] == request_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_restore_database_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.restore_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.RestoreDatabaseRequest() + + assert args[0] == request_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_backup_schedule_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + call.return_value = schedule.BackupSchedule() + client.create_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateBackupScheduleRequest() + + assert args[0] == request_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_backup_schedule_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_backup_schedule), "__call__" + ) as call: + call.return_value = schedule.BackupSchedule() + client.get_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetBackupScheduleRequest() + + assert args[0] == request_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_backup_schedules_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + call.return_value = firestore_admin.ListBackupSchedulesResponse() + client.list_backup_schedules(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListBackupSchedulesRequest() + + assert args[0] == request_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_backup_schedule_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_backup_schedule), "__call__" + ) as call: + call.return_value = schedule.BackupSchedule() + client.update_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.UpdateBackupScheduleRequest() + + assert args[0] == request_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_backup_schedule_empty_call_grpc(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__call__" + ) as call: + call.return_value = None + client.delete_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteBackupScheduleRequest() + + assert args[0] == request_msg + + +def test_transport_kind_grpc_asyncio(): + transport = FirestoreAdminAsyncClient.get_transport_class("grpc_asyncio")( + credentials=async_anonymous_credentials() + ) + assert transport.kind == "grpc_asyncio" + + +def test_initialize_client_w_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + 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_index_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_index), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.create_index(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateIndexRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_indexes_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_indexes), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListIndexesResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_indexes(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListIndexesRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_index_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_index), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + index.Index( + name="name_value", + query_scope=index.Index.QueryScope.COLLECTION, + api_scope=index.Index.ApiScope.DATASTORE_MODE_API, + state=index.Index.State.CREATING, + density=index.Index.Density.SPARSE_ALL, + multikey=True, + shard_count=1178, + ) + ) + await client.get_index(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetIndexRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_index_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_index), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_index(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteIndexRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_field_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_field), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + field.Field( + name="name_value", + ) + ) + await client.get_field(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetFieldRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_field_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_field), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.update_field(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.UpdateFieldRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_fields_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_fields), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListFieldsResponse( + next_page_token="next_page_token_value", + ) + ) + await client.list_fields(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListFieldsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_export_documents_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.export_documents), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.export_documents(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ExportDocumentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_import_documents_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.import_documents), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.import_documents(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ImportDocumentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_bulk_delete_documents_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.bulk_delete_documents), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.bulk_delete_documents(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.BulkDeleteDocumentsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_database_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.create_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.create_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateDatabaseRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_database_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + database.Database( + name="name_value", + uid="uid_value", + location_id="location_id_value", + type_=database.Database.DatabaseType.FIRESTORE_NATIVE, + concurrency_mode=database.Database.ConcurrencyMode.OPTIMISTIC, + point_in_time_recovery_enablement=database.Database.PointInTimeRecoveryEnablement.POINT_IN_TIME_RECOVERY_ENABLED, + app_engine_integration_mode=database.Database.AppEngineIntegrationMode.ENABLED, + key_prefix="key_prefix_value", + delete_protection_state=database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED, + previous_id="previous_id_value", + free_tier=True, + etag="etag_value", + database_edition=database.Database.DatabaseEdition.STANDARD, + ) + ) + await client.get_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetDatabaseRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_databases_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_databases), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListDatabasesResponse( + unreachable=["unreachable_value"], + ) + ) + await client.list_databases(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListDatabasesRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_database_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.update_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.update_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.UpdateDatabaseRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_database_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.delete_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteDatabaseRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_user_creds_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + gfa_user_creds.UserCreds( + name="name_value", + state=gfa_user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) + ) + await client.create_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateUserCredsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_user_creds_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) + ) + await client.get_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetUserCredsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_user_creds_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListUserCredsResponse() + ) + await client.list_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListUserCredsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_enable_user_creds_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) + ) + await client.enable_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.EnableUserCredsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_disable_user_creds_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.disable_user_creds), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) + ) + await client.disable_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DisableUserCredsRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_reset_user_password_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.reset_user_password), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) + ) + await client.reset_user_password(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ResetUserPasswordRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_user_creds_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_user_creds), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteUserCredsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_backup), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + backup.Backup( + name="name_value", + database="database_value", + database_uid="database_uid_value", + state=backup.Backup.State.CREATING, + ) + ) + await client.get_backup(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetBackupRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backups_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_backups), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupsResponse( + unreachable=["unreachable_value"], + ) + ) + await client.list_backups(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListBackupsRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_backup), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_backup(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteBackupRequest() + + assert args[0] == request_msg + + +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_restore_database_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.restore_database), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + await client.restore_database(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.RestoreDatabaseRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_schedule_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule( + name="name_value", + ) + ) + await client.create_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateBackupScheduleRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_schedule_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule( + name="name_value", + ) + ) + await client.get_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetBackupScheduleRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_schedules_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.list_backup_schedules), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + firestore_admin.ListBackupSchedulesResponse() + ) + await client.list_backup_schedules(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListBackupSchedulesRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_schedule_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.update_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + schedule.BackupSchedule( + name="name_value", + ) + ) + await client.update_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.UpdateBackupScheduleRequest() + + assert args[0] == request_msg + + +# This test is a coverage 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_backup_schedule_empty_call_grpc_asyncio(): + client = FirestoreAdminAsyncClient( + credentials=async_anonymous_credentials(), transport="grpc_asyncio", ) - # Mock the actual call, and fake the request. + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_backup_schedule), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_backup_schedule(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteBackupScheduleRequest() + + assert args[0] == request_msg + + +def test_transport_kind_rest(): + transport = FirestoreAdminClient.get_transport_class("rest")( + credentials=ga_credentials.AnonymousCredentials() + ) + assert transport.kind == "rest" + + +def test_create_index_rest_bad_request(request_type=firestore_admin.CreateIndexRequest): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/databases/sample2/collectionGroups/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.create_index(request) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.CreateIndexRequest, + dict, + ], +) +def test_create_index_rest_call_success(request_type): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + } + request_init["index"] = { + "name": "name_value", + "query_scope": 1, + "api_scope": 1, + "fields": [ + { + "field_path": "field_path_value", + "order": 1, + "array_config": 1, + "vector_config": {"dimension": 966, "flat": {}}, + } + ], + "state": 1, + "density": 1, + "multikey": True, + "shard_count": 1178, + } + # 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 = firestore_admin.CreateIndexRequest.meta.fields["index"] + + 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["index"].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["index"][field])): + del request_init["index"][field][i][subfield] + else: + del request_init["index"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.create_index(request) + + # Establish that the response is the type that we expect. + json_return_value = json_format.MessageToJson(return_value) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_index_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_create_index" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_create_index_with_metadata" + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_create_index" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.CreateIndexRequest.pb( + firestore_admin.CreateIndexRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value + + request = firestore_admin.CreateIndexRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata + + client.create_index( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_list_indexes_rest_bad_request(request_type=firestore_admin.ListIndexesRequest): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.list_indexes(request) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.ListIndexesRequest, + dict, + ], +) +def test_list_indexes_rest_call_success(request_type): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/databases/sample2/collectionGroups/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 = firestore_admin.ListIndexesResponse( + 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 = firestore_admin.ListIndexesResponse.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_indexes(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListIndexesPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_indexes_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(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.FirestoreAdminRestInterceptor, "post_list_indexes" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_list_indexes_with_metadata" + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_list_indexes" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.ListIndexesRequest.pb( + firestore_admin.ListIndexesRequest() + ) + 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 = firestore_admin.ListIndexesResponse.to_json( + firestore_admin.ListIndexesResponse() + ) + req.return_value.content = return_value + + request = firestore_admin.ListIndexesRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = firestore_admin.ListIndexesResponse() + post_with_metadata.return_value = ( + firestore_admin.ListIndexesResponse(), + metadata, + ) + + client.list_indexes( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_index_rest_bad_request(request_type=firestore_admin.GetIndexRequest): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = 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_index(request) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.GetIndexRequest, + dict, + ], +) +def test_get_index_rest_call_success(request_type): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/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 = index.Index( + name="name_value", + query_scope=index.Index.QueryScope.COLLECTION, + api_scope=index.Index.ApiScope.DATASTORE_MODE_API, + state=index.Index.State.CREATING, + density=index.Index.Density.SPARSE_ALL, + multikey=True, + shard_count=1178, + ) + + # 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 = index.Index.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_index(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, index.Index) + assert response.name == "name_value" + assert response.query_scope == index.Index.QueryScope.COLLECTION + assert response.api_scope == index.Index.ApiScope.DATASTORE_MODE_API + assert response.state == index.Index.State.CREATING + assert response.density == index.Index.Density.SPARSE_ALL + assert response.multikey is True + assert response.shard_count == 1178 + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_index_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(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.FirestoreAdminRestInterceptor, "post_get_index" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_get_index_with_metadata" + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_get_index" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.GetIndexRequest.pb( + firestore_admin.GetIndexRequest() + ) + 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 = index.Index.to_json(index.Index()) + req.return_value.content = return_value + + request = firestore_admin.GetIndexRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = index.Index() + post_with_metadata.return_value = index.Index(), metadata + + client.get_index( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_delete_index_rest_bad_request(request_type=firestore_admin.DeleteIndexRequest): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = 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_index(request) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.DeleteIndexRequest, + dict, + ], +) +def test_delete_index_rest_call_success(request_type): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/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 = 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_index(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_index_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(transport=transport) + with mock.patch.object( - type(client.transport.update_backup_schedule), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - schedule.BackupSchedule( - name="name_value", - ) + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_delete_index" + ) as pre: + pre.assert_not_called() + pb_message = firestore_admin.DeleteIndexRequest.pb( + firestore_admin.DeleteIndexRequest() ) - await client.update_backup_schedule(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 = firestore_admin.UpdateBackupScheduleRequest() + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - assert args[0] == request_msg + request = firestore_admin.DeleteIndexRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + client.delete_index( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) -# This test is a coverage 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_backup_schedule_empty_call_grpc_asyncio(): - client = FirestoreAdminAsyncClient( - credentials=async_anonymous_credentials(), - transport="grpc_asyncio", + pre.assert_called_once() + + +def test_get_field_rest_bad_request(request_type=firestore_admin.GetFieldRequest): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = 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_field(request) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.GetFieldRequest, + dict, + ], +) +def test_get_field_rest_call_success(request_type): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) - # Mock the actual call, and fake the request. + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/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 = field.Field( + name="name_value", + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = field.Field.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_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_field(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, field.Field) + assert response.name == "name_value" + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_field_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(transport=transport) + with mock.patch.object( - type(client.transport.delete_backup_schedule), "__call__" - ) as call: - # Designate an appropriate return value for the call. - call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) - await client.delete_backup_schedule(request=None) + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_get_field" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_get_field_with_metadata" + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_get_field" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.GetFieldRequest.pb( + firestore_admin.GetFieldRequest() + ) + 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 = firestore_admin.DeleteBackupScheduleRequest() + 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 = field.Field.to_json(field.Field()) + req.return_value.content = return_value - assert args[0] == request_msg + request = firestore_admin.GetFieldRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = field.Field() + post_with_metadata.return_value = field.Field(), metadata + client.get_field( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) -def test_transport_kind_rest(): - transport = FirestoreAdminClient.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_index_rest_bad_request(request_type=firestore_admin.CreateIndexRequest): +def test_update_field_rest_bad_request(request_type=firestore_admin.UpdateFieldRequest): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + "field": { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" + } } request = request_type(**request_init) @@ -15228,45 +20025,61 @@ def test_create_index_rest_bad_request(request_type=firestore_admin.CreateIndexR response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.create_index(request) + client.update_field(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.CreateIndexRequest, + firestore_admin.UpdateFieldRequest, dict, ], ) -def test_create_index_rest_call_success(request_type): +def test_update_field_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding request_init = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" + "field": { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" + } } - request_init["index"] = { - "name": "name_value", - "query_scope": 1, - "api_scope": 1, - "fields": [ - { - "field_path": "field_path_value", - "order": 1, - "array_config": 1, - "vector_config": {"dimension": 966, "flat": {}}, - } - ], - "state": 1, + request_init["field"] = { + "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4", + "index_config": { + "indexes": [ + { + "name": "name_value", + "query_scope": 1, + "api_scope": 1, + "fields": [ + { + "field_path": "field_path_value", + "order": 1, + "array_config": 1, + "vector_config": {"dimension": 966, "flat": {}}, + } + ], + "state": 1, + "density": 1, + "multikey": True, + "shard_count": 1178, + } + ], + "uses_ancestor_config": True, + "ancestor_field": "ancestor_field_value", + "reverting": True, + }, + "ttl_config": {"state": 1}, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = firestore_admin.CreateIndexRequest.meta.fields["index"] + test_field = firestore_admin.UpdateFieldRequest.meta.fields["field"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -15294,7 +20107,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["index"].items(): # pragma: NO COVER + for field, value in request_init["field"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -15324,10 +20137,10 @@ def get_message_fields(field): subfield = subfield_to_delete.get("subfield") if subfield: if field_repeated: - for i in range(0, len(request_init["index"][field])): - del request_init["index"][field][i][subfield] + for i in range(0, len(request_init["field"][field])): + del request_init["field"][field][i][subfield] else: - del request_init["index"][field][subfield] + del request_init["field"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -15342,14 +20155,14 @@ def get_message_fields(field): response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.create_index(request) + response = client.update_field(request) # Establish that the response is the type that we expect. json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_index_rest_interceptors(null_interceptor): +def test_update_field_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15365,17 +20178,17 @@ def test_create_index_rest_interceptors(null_interceptor): ) as transcode, mock.patch.object( operation.Operation, "_set_result_from_operation" ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_create_index" + transports.FirestoreAdminRestInterceptor, "post_update_field" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_create_index_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_update_field_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_create_index" + transports.FirestoreAdminRestInterceptor, "pre_update_field" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.CreateIndexRequest.pb( - firestore_admin.CreateIndexRequest() + pb_message = firestore_admin.UpdateFieldRequest.pb( + firestore_admin.UpdateFieldRequest() ) transcode.return_value = { "method": "post", @@ -15390,7 +20203,7 @@ def test_create_index_rest_interceptors(null_interceptor): return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = firestore_admin.CreateIndexRequest() + request = firestore_admin.UpdateFieldRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -15399,7 +20212,7 @@ def test_create_index_rest_interceptors(null_interceptor): post.return_value = operations_pb2.Operation() post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.create_index( + client.update_field( request, metadata=[ ("key", "val"), @@ -15412,7 +20225,7 @@ def test_create_index_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_indexes_rest_bad_request(request_type=firestore_admin.ListIndexesRequest): +def test_list_fields_rest_bad_request(request_type=firestore_admin.ListFieldsRequest): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -15434,17 +20247,17 @@ def test_list_indexes_rest_bad_request(request_type=firestore_admin.ListIndexesR response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.list_indexes(request) + client.list_fields(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.ListIndexesRequest, + firestore_admin.ListFieldsRequest, dict, ], ) -def test_list_indexes_rest_call_success(request_type): +def test_list_fields_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -15458,7 +20271,7 @@ def test_list_indexes_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 = firestore_admin.ListIndexesResponse( + return_value = firestore_admin.ListFieldsResponse( next_page_token="next_page_token_value", ) @@ -15467,20 +20280,20 @@ def test_list_indexes_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = firestore_admin.ListIndexesResponse.pb(return_value) + return_value = firestore_admin.ListFieldsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_indexes(request) + response = client.list_fields(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListIndexesPager) + assert isinstance(response, pagers.ListFieldsPager) assert response.next_page_token == "next_page_token_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_indexes_rest_interceptors(null_interceptor): +def test_list_fields_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15494,17 +20307,17 @@ def test_list_indexes_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_list_indexes" + transports.FirestoreAdminRestInterceptor, "post_list_fields" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_list_indexes_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_list_fields_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_list_indexes" + transports.FirestoreAdminRestInterceptor, "pre_list_fields" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.ListIndexesRequest.pb( - firestore_admin.ListIndexesRequest() + pb_message = firestore_admin.ListFieldsRequest.pb( + firestore_admin.ListFieldsRequest() ) transcode.return_value = { "method": "post", @@ -15516,24 +20329,21 @@ def test_list_indexes_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 = firestore_admin.ListIndexesResponse.to_json( - firestore_admin.ListIndexesResponse() + return_value = firestore_admin.ListFieldsResponse.to_json( + firestore_admin.ListFieldsResponse() ) req.return_value.content = return_value - request = firestore_admin.ListIndexesRequest() + request = firestore_admin.ListFieldsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = firestore_admin.ListIndexesResponse() - post_with_metadata.return_value = ( - firestore_admin.ListIndexesResponse(), - metadata, - ) + post.return_value = firestore_admin.ListFieldsResponse() + post_with_metadata.return_value = firestore_admin.ListFieldsResponse(), metadata - client.list_indexes( + client.list_fields( request, metadata=[ ("key", "val"), @@ -15546,14 +20356,14 @@ def test_list_indexes_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_index_rest_bad_request(request_type=firestore_admin.GetIndexRequest): +def test_export_documents_rest_bad_request( + request_type=firestore_admin.ExportDocumentsRequest, +): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" - } + request_init = {"name": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15568,59 +20378,45 @@ def test_get_index_rest_bad_request(request_type=firestore_admin.GetIndexRequest response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_index(request) + client.export_documents(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.GetIndexRequest, + firestore_admin.ExportDocumentsRequest, dict, ], ) -def test_get_index_rest_call_success(request_type): +def test_export_documents_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" - } + request_init = {"name": "projects/sample1/databases/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 = index.Index( - name="name_value", - query_scope=index.Index.QueryScope.COLLECTION, - api_scope=index.Index.ApiScope.DATASTORE_MODE_API, - state=index.Index.State.CREATING, - ) + return_value = operations_pb2.Operation(name="operations/spam") # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = index.Index.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_index(request) + response = client.export_documents(request) # Establish that the response is the type that we expect. - assert isinstance(response, index.Index) - assert response.name == "name_value" - assert response.query_scope == index.Index.QueryScope.COLLECTION - assert response.api_scope == index.Index.ApiScope.DATASTORE_MODE_API - assert response.state == index.Index.State.CREATING + json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_index_rest_interceptors(null_interceptor): +def test_export_documents_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15634,17 +20430,19 @@ def test_get_index_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_get_index" + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_export_documents" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_get_index_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_export_documents_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_get_index" + transports.FirestoreAdminRestInterceptor, "pre_export_documents" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.GetIndexRequest.pb( - firestore_admin.GetIndexRequest() + pb_message = firestore_admin.ExportDocumentsRequest.pb( + firestore_admin.ExportDocumentsRequest() ) transcode.return_value = { "method": "post", @@ -15656,19 +20454,19 @@ def test_get_index_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 = index.Index.to_json(index.Index()) + return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = firestore_admin.GetIndexRequest() + request = firestore_admin.ExportDocumentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = index.Index() - post_with_metadata.return_value = index.Index(), metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.get_index( + client.export_documents( request, metadata=[ ("key", "val"), @@ -15681,14 +20479,14 @@ def test_get_index_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_index_rest_bad_request(request_type=firestore_admin.DeleteIndexRequest): +def test_import_documents_rest_bad_request( + request_type=firestore_admin.ImportDocumentsRequest, +): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" - } + request_init = {"name": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15703,47 +20501,45 @@ def test_delete_index_rest_bad_request(request_type=firestore_admin.DeleteIndexR response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.delete_index(request) + client.import_documents(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.DeleteIndexRequest, + firestore_admin.ImportDocumentsRequest, dict, ], ) -def test_delete_index_rest_call_success(request_type): +def test_import_documents_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/indexes/sample4" - } + request_init = {"name": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = None + return_value = operations_pb2.Operation(name="operations/spam") # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = "" + json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_index(request) + response = client.import_documents(request) # Establish that the response is the type that we expect. - assert response is None + json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_index_rest_interceptors(null_interceptor): +def test_import_documents_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15757,11 +20553,19 @@ def test_delete_index_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_delete_index" + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_import_documents" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_import_documents_with_metadata" + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_import_documents" ) as pre: - pre.assert_not_called() - pb_message = firestore_admin.DeleteIndexRequest.pb( - firestore_admin.DeleteIndexRequest() + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.ImportDocumentsRequest.pb( + firestore_admin.ImportDocumentsRequest() ) transcode.return_value = { "method": "post", @@ -15773,15 +20577,19 @@ def test_delete_index_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value - request = firestore_admin.DeleteIndexRequest() + request = firestore_admin.ImportDocumentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.delete_index( + client.import_documents( request, metadata=[ ("key", "val"), @@ -15790,16 +20598,18 @@ def test_delete_index_rest_interceptors(null_interceptor): ) pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() -def test_get_field_rest_bad_request(request_type=firestore_admin.GetFieldRequest): +def test_bulk_delete_documents_rest_bad_request( + request_type=firestore_admin.BulkDeleteDocumentsRequest, +): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" - } + request_init = {"name": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15814,53 +20624,45 @@ def test_get_field_rest_bad_request(request_type=firestore_admin.GetFieldRequest response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_field(request) + client.bulk_delete_documents(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.GetFieldRequest, + firestore_admin.BulkDeleteDocumentsRequest, dict, ], ) -def test_get_field_rest_call_success(request_type): +def test_bulk_delete_documents_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" - } + request_init = {"name": "projects/sample1/databases/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 = field.Field( - name="name_value", - ) + return_value = operations_pb2.Operation(name="operations/spam") # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = field.Field.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_field(request) + response = client.bulk_delete_documents(request) # Establish that the response is the type that we expect. - assert isinstance(response, field.Field) - assert response.name == "name_value" + json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_field_rest_interceptors(null_interceptor): +def test_bulk_delete_documents_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -15874,17 +20676,20 @@ def test_get_field_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_get_field" + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_bulk_delete_documents" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_get_field_with_metadata" + transports.FirestoreAdminRestInterceptor, + "post_bulk_delete_documents_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_get_field" + transports.FirestoreAdminRestInterceptor, "pre_bulk_delete_documents" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.GetFieldRequest.pb( - firestore_admin.GetFieldRequest() + pb_message = firestore_admin.BulkDeleteDocumentsRequest.pb( + firestore_admin.BulkDeleteDocumentsRequest() ) transcode.return_value = { "method": "post", @@ -15896,19 +20701,19 @@ def test_get_field_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 = field.Field.to_json(field.Field()) + return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = firestore_admin.GetFieldRequest() + request = firestore_admin.BulkDeleteDocumentsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = field.Field() - post_with_metadata.return_value = field.Field(), metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.get_field( + client.bulk_delete_documents( request, metadata=[ ("key", "val"), @@ -15921,16 +20726,14 @@ def test_get_field_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_field_rest_bad_request(request_type=firestore_admin.UpdateFieldRequest): +def test_create_database_rest_bad_request( + request_type=firestore_admin.CreateDatabaseRequest, +): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "field": { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" - } - } + request_init = {"parent": "projects/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -15945,58 +20748,60 @@ def test_update_field_rest_bad_request(request_type=firestore_admin.UpdateFieldR response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.update_field(request) + client.create_database(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.UpdateFieldRequest, + firestore_admin.CreateDatabaseRequest, dict, ], ) -def test_update_field_rest_call_success(request_type): +def test_create_database_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "field": { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4" - } - } - request_init["field"] = { - "name": "projects/sample1/databases/sample2/collectionGroups/sample3/fields/sample4", - "index_config": { - "indexes": [ - { - "name": "name_value", - "query_scope": 1, - "api_scope": 1, - "fields": [ - { - "field_path": "field_path_value", - "order": 1, - "array_config": 1, - "vector_config": {"dimension": 966, "flat": {}}, - } - ], - "state": 1, - } + request_init = {"parent": "projects/sample1"} + request_init["database"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "delete_time": {}, + "location_id": "location_id_value", + "type_": 1, + "concurrency_mode": 1, + "version_retention_period": {"seconds": 751, "nanos": 543}, + "earliest_version_time": {}, + "point_in_time_recovery_enablement": 1, + "app_engine_integration_mode": 1, + "key_prefix": "key_prefix_value", + "delete_protection_state": 1, + "cmek_config": { + "kms_key_name": "kms_key_name_value", + "active_key_version": [ + "active_key_version_value1", + "active_key_version_value2", ], - "uses_ancestor_config": True, - "ancestor_field": "ancestor_field_value", - "reverting": True, }, - "ttl_config": {"state": 1}, + "previous_id": "previous_id_value", + "source_info": { + "backup": {"backup": "backup_value"}, + "operation": "operation_value", + }, + "free_tier": True, + "etag": "etag_value", + "database_edition": 1, } # The version of a generated dependency at test runtime may differ from the version used during generation. # Delete any fields which are not present in the current runtime dependency # See https://github.com/googleapis/gapic-generator-python/issues/1748 # Determine if the message type is proto-plus or protobuf - test_field = firestore_admin.UpdateFieldRequest.meta.fields["field"] + test_field = firestore_admin.CreateDatabaseRequest.meta.fields["database"] def get_message_fields(field): # Given a field which is a message (composite type), return a list with @@ -16024,7 +20829,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["field"].items(): # pragma: NO COVER + for field, value in request_init["database"].items(): # pragma: NO COVER result = None is_repeated = False # For repeated fields @@ -16046,40 +20851,200 @@ def get_message_fields(field): } ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["field"][field])): - del request_init["field"][field][i][subfield] - else: - del request_init["field"][field][subfield] + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["database"][field])): + del request_init["database"][field][i][subfield] + else: + del request_init["database"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.create_database(request) + + # Establish that the response is the type that we expect. + json_return_value = json_format.MessageToJson(return_value) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_database_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_create_database" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "post_create_database_with_metadata" + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_create_database" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.CreateDatabaseRequest.pb( + firestore_admin.CreateDatabaseRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + return_value = json_format.MessageToJson(operations_pb2.Operation()) + req.return_value.content = return_value + + request = firestore_admin.CreateDatabaseRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + post_with_metadata.return_value = operations_pb2.Operation(), metadata + + client.create_database( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_database_rest_bad_request(request_type=firestore_admin.GetDatabaseRequest): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/databases/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + response_value.status_code = 400 + response_value.request = mock.Mock() + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + client.get_database(request) + + +@pytest.mark.parametrize( + "request_type", + [ + firestore_admin.GetDatabaseRequest, + dict, + ], +) +def test_get_database_rest_call_success(request_type): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = database.Database( + name="name_value", + uid="uid_value", + location_id="location_id_value", + type_=database.Database.DatabaseType.FIRESTORE_NATIVE, + concurrency_mode=database.Database.ConcurrencyMode.OPTIMISTIC, + point_in_time_recovery_enablement=database.Database.PointInTimeRecoveryEnablement.POINT_IN_TIME_RECOVERY_ENABLED, + app_engine_integration_mode=database.Database.AppEngineIntegrationMode.ENABLED, + key_prefix="key_prefix_value", + delete_protection_state=database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED, + previous_id="previous_id_value", + free_tier=True, + etag="etag_value", + database_edition=database.Database.DatabaseEdition.STANDARD, + ) # 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 = database.Database.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_field(request) + response = client.get_database(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert isinstance(response, database.Database) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.location_id == "location_id_value" + assert response.type_ == database.Database.DatabaseType.FIRESTORE_NATIVE + assert response.concurrency_mode == database.Database.ConcurrencyMode.OPTIMISTIC + assert ( + response.point_in_time_recovery_enablement + == database.Database.PointInTimeRecoveryEnablement.POINT_IN_TIME_RECOVERY_ENABLED + ) + assert ( + response.app_engine_integration_mode + == database.Database.AppEngineIntegrationMode.ENABLED + ) + assert response.key_prefix == "key_prefix_value" + assert ( + response.delete_protection_state + == database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED + ) + assert response.previous_id == "previous_id_value" + assert response.free_tier is True + assert response.etag == "etag_value" + assert response.database_edition == database.Database.DatabaseEdition.STANDARD @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_field_rest_interceptors(null_interceptor): +def test_get_database_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16093,19 +21058,17 @@ def test_update_field_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_update_field" + transports.FirestoreAdminRestInterceptor, "post_get_database" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_update_field_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_get_database_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_update_field" + transports.FirestoreAdminRestInterceptor, "pre_get_database" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.UpdateFieldRequest.pb( - firestore_admin.UpdateFieldRequest() + pb_message = firestore_admin.GetDatabaseRequest.pb( + firestore_admin.GetDatabaseRequest() ) transcode.return_value = { "method": "post", @@ -16117,19 +21080,19 @@ def test_update_field_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) + return_value = database.Database.to_json(database.Database()) req.return_value.content = return_value - request = firestore_admin.UpdateFieldRequest() + request = firestore_admin.GetDatabaseRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata + post.return_value = database.Database() + post_with_metadata.return_value = database.Database(), metadata - client.update_field( + client.get_database( request, metadata=[ ("key", "val"), @@ -16142,14 +21105,14 @@ def test_update_field_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_fields_rest_bad_request(request_type=firestore_admin.ListFieldsRequest): +def test_list_databases_rest_bad_request( + request_type=firestore_admin.ListDatabasesRequest, +): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } + request_init = {"parent": "projects/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16164,32 +21127,30 @@ def test_list_fields_rest_bad_request(request_type=firestore_admin.ListFieldsReq response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.list_fields(request) + client.list_databases(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.ListFieldsRequest, + firestore_admin.ListDatabasesRequest, dict, ], ) -def test_list_fields_rest_call_success(request_type): +def test_list_databases_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = { - "parent": "projects/sample1/databases/sample2/collectionGroups/sample3" - } + request_init = {"parent": "projects/sample1"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = firestore_admin.ListFieldsResponse( - next_page_token="next_page_token_value", + return_value = firestore_admin.ListDatabasesResponse( + unreachable=["unreachable_value"], ) # Wrap the value into a proper Response obj @@ -16197,20 +21158,20 @@ def test_list_fields_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = firestore_admin.ListFieldsResponse.pb(return_value) + return_value = firestore_admin.ListDatabasesResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_fields(request) + response = client.list_databases(request) # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListFieldsPager) - assert response.next_page_token == "next_page_token_value" + assert isinstance(response, firestore_admin.ListDatabasesResponse) + assert response.unreachable == ["unreachable_value"] @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_fields_rest_interceptors(null_interceptor): +def test_list_databases_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16224,17 +21185,17 @@ def test_list_fields_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_list_fields" + transports.FirestoreAdminRestInterceptor, "post_list_databases" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_list_fields_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_list_databases_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_list_fields" + transports.FirestoreAdminRestInterceptor, "pre_list_databases" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.ListFieldsRequest.pb( - firestore_admin.ListFieldsRequest() + pb_message = firestore_admin.ListDatabasesRequest.pb( + firestore_admin.ListDatabasesRequest() ) transcode.return_value = { "method": "post", @@ -16246,21 +21207,24 @@ def test_list_fields_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 = firestore_admin.ListFieldsResponse.to_json( - firestore_admin.ListFieldsResponse() + return_value = firestore_admin.ListDatabasesResponse.to_json( + firestore_admin.ListDatabasesResponse() ) req.return_value.content = return_value - request = firestore_admin.ListFieldsRequest() + request = firestore_admin.ListDatabasesRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = firestore_admin.ListFieldsResponse() - post_with_metadata.return_value = firestore_admin.ListFieldsResponse(), metadata + post.return_value = firestore_admin.ListDatabasesResponse() + post_with_metadata.return_value = ( + firestore_admin.ListDatabasesResponse(), + metadata, + ) - client.list_fields( + client.list_databases( request, metadata=[ ("key", "val"), @@ -16273,14 +21237,14 @@ def test_list_fields_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_export_documents_rest_bad_request( - request_type=firestore_admin.ExportDocumentsRequest, +def test_update_database_rest_bad_request( + request_type=firestore_admin.UpdateDatabaseRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"database": {"name": "projects/sample1/databases/sample2"}} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16295,23 +21259,121 @@ def test_export_documents_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.export_documents(request) + client.update_database(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.ExportDocumentsRequest, + firestore_admin.UpdateDatabaseRequest, dict, ], ) -def test_export_documents_rest_call_success(request_type): +def test_update_database_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"database": {"name": "projects/sample1/databases/sample2"}} + request_init["database"] = { + "name": "projects/sample1/databases/sample2", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "delete_time": {}, + "location_id": "location_id_value", + "type_": 1, + "concurrency_mode": 1, + "version_retention_period": {"seconds": 751, "nanos": 543}, + "earliest_version_time": {}, + "point_in_time_recovery_enablement": 1, + "app_engine_integration_mode": 1, + "key_prefix": "key_prefix_value", + "delete_protection_state": 1, + "cmek_config": { + "kms_key_name": "kms_key_name_value", + "active_key_version": [ + "active_key_version_value1", + "active_key_version_value2", + ], + }, + "previous_id": "previous_id_value", + "source_info": { + "backup": {"backup": "backup_value"}, + "operation": "operation_value", + }, + "free_tier": True, + "etag": "etag_value", + "database_edition": 1, + } + # The version of a generated dependency at test runtime may differ from the version used during generation. + # Delete any fields which are not present in the current runtime dependency + # See https://github.com/googleapis/gapic-generator-python/issues/1748 + + # Determine if the message type is proto-plus or protobuf + test_field = firestore_admin.UpdateDatabaseRequest.meta.fields["database"] + + 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["database"].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["database"][field])): + del request_init["database"][field][i][subfield] + else: + del request_init["database"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -16326,14 +21388,14 @@ def test_export_documents_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.export_documents(request) + response = client.update_database(request) # Establish that the response is the type that we expect. json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_export_documents_rest_interceptors(null_interceptor): +def test_update_database_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16349,17 +21411,17 @@ def test_export_documents_rest_interceptors(null_interceptor): ) as transcode, mock.patch.object( operation.Operation, "_set_result_from_operation" ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_export_documents" + transports.FirestoreAdminRestInterceptor, "post_update_database" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_export_documents_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_update_database_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_export_documents" + transports.FirestoreAdminRestInterceptor, "pre_update_database" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.ExportDocumentsRequest.pb( - firestore_admin.ExportDocumentsRequest() + pb_message = firestore_admin.UpdateDatabaseRequest.pb( + firestore_admin.UpdateDatabaseRequest() ) transcode.return_value = { "method": "post", @@ -16374,7 +21436,7 @@ def test_export_documents_rest_interceptors(null_interceptor): return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = firestore_admin.ExportDocumentsRequest() + request = firestore_admin.UpdateDatabaseRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -16383,7 +21445,7 @@ def test_export_documents_rest_interceptors(null_interceptor): post.return_value = operations_pb2.Operation() post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.export_documents( + client.update_database( request, metadata=[ ("key", "val"), @@ -16396,8 +21458,8 @@ def test_export_documents_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_import_documents_rest_bad_request( - request_type=firestore_admin.ImportDocumentsRequest, +def test_delete_database_rest_bad_request( + request_type=firestore_admin.DeleteDatabaseRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -16418,17 +21480,17 @@ def test_import_documents_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.import_documents(request) + client.delete_database(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.ImportDocumentsRequest, + firestore_admin.DeleteDatabaseRequest, dict, ], ) -def test_import_documents_rest_call_success(request_type): +def test_delete_database_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -16449,14 +21511,14 @@ def test_import_documents_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.import_documents(request) + response = client.delete_database(request) # Establish that the response is the type that we expect. json_return_value = json_format.MessageToJson(return_value) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_import_documents_rest_interceptors(null_interceptor): +def test_delete_database_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16472,17 +21534,17 @@ def test_import_documents_rest_interceptors(null_interceptor): ) as transcode, mock.patch.object( operation.Operation, "_set_result_from_operation" ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_import_documents" + transports.FirestoreAdminRestInterceptor, "post_delete_database" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_import_documents_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_delete_database_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_import_documents" + transports.FirestoreAdminRestInterceptor, "pre_delete_database" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.ImportDocumentsRequest.pb( - firestore_admin.ImportDocumentsRequest() + pb_message = firestore_admin.DeleteDatabaseRequest.pb( + firestore_admin.DeleteDatabaseRequest() ) transcode.return_value = { "method": "post", @@ -16497,7 +21559,7 @@ def test_import_documents_rest_interceptors(null_interceptor): return_value = json_format.MessageToJson(operations_pb2.Operation()) req.return_value.content = return_value - request = firestore_admin.ImportDocumentsRequest() + request = firestore_admin.DeleteDatabaseRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -16506,7 +21568,7 @@ def test_import_documents_rest_interceptors(null_interceptor): post.return_value = operations_pb2.Operation() post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.import_documents( + client.delete_database( request, metadata=[ ("key", "val"), @@ -16519,14 +21581,14 @@ def test_import_documents_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_bulk_delete_documents_rest_bad_request( - request_type=firestore_admin.BulkDeleteDocumentsRequest, +def test_create_user_creds_rest_bad_request( + request_type=firestore_admin.CreateUserCredsRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"parent": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16541,45 +21603,130 @@ def test_bulk_delete_documents_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.bulk_delete_documents(request) + client.create_user_creds(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.BulkDeleteDocumentsRequest, + firestore_admin.CreateUserCredsRequest, dict, ], ) -def test_bulk_delete_documents_rest_call_success(request_type): +def test_create_user_creds_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"parent": "projects/sample1/databases/sample2"} + request_init["user_creds"] = { + "name": "name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "state": 1, + "secure_password": "secure_password_value", + "resource_identity": {"principal": "principal_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 = firestore_admin.CreateUserCredsRequest.meta.fields["user_creds"] + + 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["user_creds"].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["user_creds"][field])): + del request_init["user_creds"][field][i][subfield] + else: + del request_init["user_creds"][field][subfield] request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = gfa_user_creds.UserCreds( + name="name_value", + state=gfa_user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_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 = gfa_user_creds.UserCreds.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_return_value.encode("UTF-8") req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - response = client.bulk_delete_documents(request) + response = client.create_user_creds(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert isinstance(response, gfa_user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == gfa_user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_bulk_delete_documents_rest_interceptors(null_interceptor): +def test_create_user_creds_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16593,20 +21740,17 @@ def test_bulk_delete_documents_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_bulk_delete_documents" + transports.FirestoreAdminRestInterceptor, "post_create_user_creds" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, - "post_bulk_delete_documents_with_metadata", + transports.FirestoreAdminRestInterceptor, "post_create_user_creds_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_bulk_delete_documents" + transports.FirestoreAdminRestInterceptor, "pre_create_user_creds" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.BulkDeleteDocumentsRequest.pb( - firestore_admin.BulkDeleteDocumentsRequest() + pb_message = firestore_admin.CreateUserCredsRequest.pb( + firestore_admin.CreateUserCredsRequest() ) transcode.return_value = { "method": "post", @@ -16618,19 +21762,19 @@ def test_bulk_delete_documents_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) + return_value = gfa_user_creds.UserCreds.to_json(gfa_user_creds.UserCreds()) req.return_value.content = return_value - request = firestore_admin.BulkDeleteDocumentsRequest() + request = firestore_admin.CreateUserCredsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata + post.return_value = gfa_user_creds.UserCreds() + post_with_metadata.return_value = gfa_user_creds.UserCreds(), metadata - client.bulk_delete_documents( + client.create_user_creds( request, metadata=[ ("key", "val"), @@ -16643,14 +21787,14 @@ def test_bulk_delete_documents_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_create_database_rest_bad_request( - request_type=firestore_admin.CreateDatabaseRequest, +def test_get_user_creds_rest_bad_request( + request_type=firestore_admin.GetUserCredsRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1"} + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16665,141 +21809,55 @@ def test_create_database_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_database(request) + client.get_user_creds(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.CreateDatabaseRequest, + firestore_admin.GetUserCredsRequest, dict, ], ) -def test_create_database_rest_call_success(request_type): +def test_get_user_creds_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1"} - request_init["database"] = { - "name": "name_value", - "uid": "uid_value", - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - "delete_time": {}, - "location_id": "location_id_value", - "type_": 1, - "concurrency_mode": 1, - "version_retention_period": {"seconds": 751, "nanos": 543}, - "earliest_version_time": {}, - "point_in_time_recovery_enablement": 1, - "app_engine_integration_mode": 1, - "key_prefix": "key_prefix_value", - "delete_protection_state": 1, - "cmek_config": { - "kms_key_name": "kms_key_name_value", - "active_key_version": [ - "active_key_version_value1", - "active_key_version_value2", - ], - }, - "previous_id": "previous_id_value", - "source_info": { - "backup": {"backup": "backup_value"}, - "operation": "operation_value", - }, - "etag": "etag_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 = firestore_admin.CreateDatabaseRequest.meta.fields["database"] - - 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["database"].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["database"][field])): - del request_init["database"][field][i][subfield] - else: - del request_init["database"][field][subfield] + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_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 = user_creds.UserCreds.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_database(request) + response = client.get_user_creds(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_database_rest_interceptors(null_interceptor): +def test_get_user_creds_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16813,19 +21871,17 @@ def test_create_database_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_create_database" + transports.FirestoreAdminRestInterceptor, "post_get_user_creds" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_create_database_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_get_user_creds_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_create_database" + transports.FirestoreAdminRestInterceptor, "pre_get_user_creds" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.CreateDatabaseRequest.pb( - firestore_admin.CreateDatabaseRequest() + pb_message = firestore_admin.GetUserCredsRequest.pb( + firestore_admin.GetUserCredsRequest() ) transcode.return_value = { "method": "post", @@ -16837,19 +21893,19 @@ def test_create_database_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) + return_value = user_creds.UserCreds.to_json(user_creds.UserCreds()) req.return_value.content = return_value - request = firestore_admin.CreateDatabaseRequest() + request = firestore_admin.GetUserCredsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata + post.return_value = user_creds.UserCreds() + post_with_metadata.return_value = user_creds.UserCreds(), metadata - client.create_database( + client.get_user_creds( request, metadata=[ ("key", "val"), @@ -16862,12 +21918,14 @@ def test_create_database_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_database_rest_bad_request(request_type=firestore_admin.GetDatabaseRequest): +def test_list_user_creds_rest_bad_request( + request_type=firestore_admin.ListUserCredsRequest, +): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"parent": "projects/sample1/databases/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -16882,80 +21940,48 @@ def test_get_database_rest_bad_request(request_type=firestore_admin.GetDatabaseR response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_database(request) + client.list_user_creds(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.GetDatabaseRequest, + firestore_admin.ListUserCredsRequest, dict, ], ) -def test_get_database_rest_call_success(request_type): +def test_list_user_creds_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"parent": "projects/sample1/databases/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 = database.Database( - name="name_value", - uid="uid_value", - location_id="location_id_value", - type_=database.Database.DatabaseType.FIRESTORE_NATIVE, - concurrency_mode=database.Database.ConcurrencyMode.OPTIMISTIC, - point_in_time_recovery_enablement=database.Database.PointInTimeRecoveryEnablement.POINT_IN_TIME_RECOVERY_ENABLED, - app_engine_integration_mode=database.Database.AppEngineIntegrationMode.ENABLED, - key_prefix="key_prefix_value", - delete_protection_state=database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED, - previous_id="previous_id_value", - etag="etag_value", - ) + return_value = firestore_admin.ListUserCredsResponse() # 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 = database.Database.pb(return_value) + return_value = firestore_admin.ListUserCredsResponse.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_database(request) + response = client.list_user_creds(request) # Establish that the response is the type that we expect. - assert isinstance(response, database.Database) - assert response.name == "name_value" - assert response.uid == "uid_value" - assert response.location_id == "location_id_value" - assert response.type_ == database.Database.DatabaseType.FIRESTORE_NATIVE - assert response.concurrency_mode == database.Database.ConcurrencyMode.OPTIMISTIC - assert ( - response.point_in_time_recovery_enablement - == database.Database.PointInTimeRecoveryEnablement.POINT_IN_TIME_RECOVERY_ENABLED - ) - assert ( - response.app_engine_integration_mode - == database.Database.AppEngineIntegrationMode.ENABLED - ) - assert response.key_prefix == "key_prefix_value" - assert ( - response.delete_protection_state - == database.Database.DeleteProtectionState.DELETE_PROTECTION_DISABLED - ) - assert response.previous_id == "previous_id_value" - assert response.etag == "etag_value" + assert isinstance(response, firestore_admin.ListUserCredsResponse) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_database_rest_interceptors(null_interceptor): +def test_list_user_creds_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -16969,17 +21995,17 @@ def test_get_database_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_get_database" + transports.FirestoreAdminRestInterceptor, "post_list_user_creds" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_get_database_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_list_user_creds_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_get_database" + transports.FirestoreAdminRestInterceptor, "pre_list_user_creds" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.GetDatabaseRequest.pb( - firestore_admin.GetDatabaseRequest() + pb_message = firestore_admin.ListUserCredsRequest.pb( + firestore_admin.ListUserCredsRequest() ) transcode.return_value = { "method": "post", @@ -16991,19 +22017,24 @@ def test_get_database_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 = database.Database.to_json(database.Database()) + return_value = firestore_admin.ListUserCredsResponse.to_json( + firestore_admin.ListUserCredsResponse() + ) req.return_value.content = return_value - request = firestore_admin.GetDatabaseRequest() + request = firestore_admin.ListUserCredsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = database.Database() - post_with_metadata.return_value = database.Database(), metadata + post.return_value = firestore_admin.ListUserCredsResponse() + post_with_metadata.return_value = ( + firestore_admin.ListUserCredsResponse(), + metadata, + ) - client.get_database( + client.list_user_creds( request, metadata=[ ("key", "val"), @@ -17016,14 +22047,14 @@ def test_get_database_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_list_databases_rest_bad_request( - request_type=firestore_admin.ListDatabasesRequest, +def test_enable_user_creds_rest_bad_request( + request_type=firestore_admin.EnableUserCredsRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1"} + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17038,30 +22069,32 @@ def test_list_databases_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_databases(request) + client.enable_user_creds(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.ListDatabasesRequest, + firestore_admin.EnableUserCredsRequest, dict, ], ) -def test_list_databases_rest_call_success(request_type): +def test_enable_user_creds_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1"} + request_init = {"name": "projects/sample1/databases/sample2/userCreds/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 = firestore_admin.ListDatabasesResponse( - unreachable=["unreachable_value"], + return_value = user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", ) # Wrap the value into a proper Response obj @@ -17069,20 +22102,22 @@ def test_list_databases_rest_call_success(request_type): response_value.status_code = 200 # Convert return value to protobuf type - return_value = firestore_admin.ListDatabasesResponse.pb(return_value) + return_value = user_creds.UserCreds.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_databases(request) + response = client.enable_user_creds(request) # Establish that the response is the type that we expect. - assert isinstance(response, firestore_admin.ListDatabasesResponse) - assert response.unreachable == ["unreachable_value"] + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_list_databases_rest_interceptors(null_interceptor): +def test_enable_user_creds_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17096,17 +22131,17 @@ def test_list_databases_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_list_databases" + transports.FirestoreAdminRestInterceptor, "post_enable_user_creds" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_list_databases_with_metadata" + transports.FirestoreAdminRestInterceptor, "post_enable_user_creds_with_metadata" ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_list_databases" + transports.FirestoreAdminRestInterceptor, "pre_enable_user_creds" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.ListDatabasesRequest.pb( - firestore_admin.ListDatabasesRequest() + pb_message = firestore_admin.EnableUserCredsRequest.pb( + firestore_admin.EnableUserCredsRequest() ) transcode.return_value = { "method": "post", @@ -17118,24 +22153,19 @@ def test_list_databases_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 = firestore_admin.ListDatabasesResponse.to_json( - firestore_admin.ListDatabasesResponse() - ) + return_value = user_creds.UserCreds.to_json(user_creds.UserCreds()) req.return_value.content = return_value - request = firestore_admin.ListDatabasesRequest() + request = firestore_admin.EnableUserCredsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = firestore_admin.ListDatabasesResponse() - post_with_metadata.return_value = ( - firestore_admin.ListDatabasesResponse(), - metadata, - ) + post.return_value = user_creds.UserCreds() + post_with_metadata.return_value = user_creds.UserCreds(), metadata - client.list_databases( + client.enable_user_creds( request, metadata=[ ("key", "val"), @@ -17148,14 +22178,14 @@ def test_list_databases_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_update_database_rest_bad_request( - request_type=firestore_admin.UpdateDatabaseRequest, +def test_disable_user_creds_rest_bad_request( + request_type=firestore_admin.DisableUserCredsRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"database": {"name": "projects/sample1/databases/sample2"}} + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17170,141 +22200,187 @@ def test_update_database_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_database(request) + client.disable_user_creds(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.UpdateDatabaseRequest, + firestore_admin.DisableUserCredsRequest, dict, ], ) -def test_update_database_rest_call_success(request_type): +def test_disable_user_creds_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"database": {"name": "projects/sample1/databases/sample2"}} - request_init["database"] = { - "name": "projects/sample1/databases/sample2", - "uid": "uid_value", - "create_time": {"seconds": 751, "nanos": 543}, - "update_time": {}, - "delete_time": {}, - "location_id": "location_id_value", - "type_": 1, - "concurrency_mode": 1, - "version_retention_period": {"seconds": 751, "nanos": 543}, - "earliest_version_time": {}, - "point_in_time_recovery_enablement": 1, - "app_engine_integration_mode": 1, - "key_prefix": "key_prefix_value", - "delete_protection_state": 1, - "cmek_config": { - "kms_key_name": "kms_key_name_value", - "active_key_version": [ - "active_key_version_value1", - "active_key_version_value2", - ], - }, - "previous_id": "previous_id_value", - "source_info": { - "backup": {"backup": "backup_value"}, - "operation": "operation_value", - }, - "etag": "etag_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 + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} + request = request_type(**request_init) - # Determine if the message type is proto-plus or protobuf - test_field = firestore_admin.UpdateDatabaseRequest.meta.fields["database"] + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_value", + ) - 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 - if hasattr(field, "message") and field.message: - is_field_type_proto_plus_type = not hasattr(field.message, "DESCRIPTOR") + # Convert return value to protobuf type + return_value = user_creds.UserCreds.pb(return_value) + json_return_value = json_format.MessageToJson(return_value) + response_value.content = json_return_value.encode("UTF-8") + req.return_value = response_value + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + response = client.disable_user_creds(request) - if is_field_type_proto_plus_type: - message_fields = field.message.meta.fields.values() - # Add `# pragma: NO COVER` because there may not be any `*_pb2` field types - else: # pragma: NO COVER - message_fields = field.message.DESCRIPTOR.fields - return message_fields + # Establish that the response is the type that we expect. + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" - runtime_nested_fields = [ - (field.name, nested_field.name) - for field in get_message_fields(test_field) - for nested_field in get_message_fields(field) - ] - subfields_not_in_runtime = [] +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_disable_user_creds_rest_interceptors(null_interceptor): + transport = transports.FirestoreAdminRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.FirestoreAdminRestInterceptor(), + ) + client = FirestoreAdminClient(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.FirestoreAdminRestInterceptor, "post_disable_user_creds" + ) as post, mock.patch.object( + transports.FirestoreAdminRestInterceptor, + "post_disable_user_creds_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.FirestoreAdminRestInterceptor, "pre_disable_user_creds" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = firestore_admin.DisableUserCredsRequest.pb( + firestore_admin.DisableUserCredsRequest() + ) + 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 = user_creds.UserCreds.to_json(user_creds.UserCreds()) + req.return_value.content = return_value + + request = firestore_admin.DisableUserCredsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = user_creds.UserCreds() + post_with_metadata.return_value = user_creds.UserCreds(), metadata + + client.disable_user_creds( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_reset_user_password_rest_bad_request( + request_type=firestore_admin.ResetUserPasswordRequest, +): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/databases/sample2/userCreds/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.reset_user_password(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["database"].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", + [ + firestore_admin.ResetUserPasswordRequest, + dict, + ], +) +def test_reset_user_password_rest_call_success(request_type): + client = FirestoreAdminClient( + 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["database"][field])): - del request_init["database"][field][i][subfield] - else: - del request_init["database"][field][subfield] + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = user_creds.UserCreds( + name="name_value", + state=user_creds.UserCreds.State.ENABLED, + secure_password="secure_password_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 = user_creds.UserCreds.pb(return_value) json_return_value = json_format.MessageToJson(return_value) response_value.content = json_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_database(request) + response = client.reset_user_password(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert isinstance(response, user_creds.UserCreds) + assert response.name == "name_value" + assert response.state == user_creds.UserCreds.State.ENABLED + assert response.secure_password == "secure_password_value" @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_database_rest_interceptors(null_interceptor): +def test_reset_user_password_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17318,19 +22394,18 @@ def test_update_database_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_update_database" + transports.FirestoreAdminRestInterceptor, "post_reset_user_password" ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_update_database_with_metadata" + transports.FirestoreAdminRestInterceptor, + "post_reset_user_password_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_update_database" + transports.FirestoreAdminRestInterceptor, "pre_reset_user_password" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = firestore_admin.UpdateDatabaseRequest.pb( - firestore_admin.UpdateDatabaseRequest() + pb_message = firestore_admin.ResetUserPasswordRequest.pb( + firestore_admin.ResetUserPasswordRequest() ) transcode.return_value = { "method": "post", @@ -17342,19 +22417,19 @@ def test_update_database_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) + return_value = user_creds.UserCreds.to_json(user_creds.UserCreds()) req.return_value.content = return_value - request = firestore_admin.UpdateDatabaseRequest() + request = firestore_admin.ResetUserPasswordRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata + post.return_value = user_creds.UserCreds() + post_with_metadata.return_value = user_creds.UserCreds(), metadata - client.update_database( + client.reset_user_password( request, metadata=[ ("key", "val"), @@ -17367,14 +22442,14 @@ def test_update_database_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_delete_database_rest_bad_request( - request_type=firestore_admin.DeleteDatabaseRequest, +def test_delete_user_creds_rest_bad_request( + request_type=firestore_admin.DeleteUserCredsRequest, ): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -17389,45 +22464,45 @@ def test_delete_database_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_database(request) + client.delete_user_creds(request) @pytest.mark.parametrize( "request_type", [ - firestore_admin.DeleteDatabaseRequest, + firestore_admin.DeleteUserCredsRequest, dict, ], ) -def test_delete_database_rest_call_success(request_type): +def test_delete_user_creds_rest_call_success(request_type): client = FirestoreAdminClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/databases/sample2"} + request_init = {"name": "projects/sample1/databases/sample2/userCreds/sample3"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = operations_pb2.Operation(name="operations/spam") + return_value = None # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - json_return_value = json_format.MessageToJson(return_value) + 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_database(request) + response = client.delete_user_creds(request) # Establish that the response is the type that we expect. - json_return_value = json_format.MessageToJson(return_value) + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_delete_database_rest_interceptors(null_interceptor): +def test_delete_user_creds_rest_interceptors(null_interceptor): transport = transports.FirestoreAdminRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -17441,19 +22516,11 @@ def test_delete_database_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - operation.Operation, "_set_result_from_operation" - ), mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_delete_database" - ) as post, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "post_delete_database_with_metadata" - ) as post_with_metadata, mock.patch.object( - transports.FirestoreAdminRestInterceptor, "pre_delete_database" + transports.FirestoreAdminRestInterceptor, "pre_delete_user_creds" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = firestore_admin.DeleteDatabaseRequest.pb( - firestore_admin.DeleteDatabaseRequest() + pb_message = firestore_admin.DeleteUserCredsRequest.pb( + firestore_admin.DeleteUserCredsRequest() ) transcode.return_value = { "method": "post", @@ -17465,19 +22532,15 @@ def test_delete_database_rest_interceptors(null_interceptor): req.return_value = mock.Mock() req.return_value.status_code = 200 req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - return_value = json_format.MessageToJson(operations_pb2.Operation()) - req.return_value.content = return_value - request = firestore_admin.DeleteDatabaseRequest() + request = firestore_admin.DeleteUserCredsRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = operations_pb2.Operation() - post_with_metadata.return_value = operations_pb2.Operation(), metadata - client.delete_database( + client.delete_user_creds( request, metadata=[ ("key", "val"), @@ -17486,8 +22549,6 @@ def test_delete_database_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() def test_get_backup_rest_bad_request(request_type=firestore_admin.GetBackupRequest): @@ -19333,6 +24394,156 @@ def test_delete_database_empty_call_rest(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_create_user_creds_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.create_user_creds), "__call__" + ) as call: + client.create_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.CreateUserCredsRequest() + + assert args[0] == request_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_user_creds_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.get_user_creds), "__call__") as call: + client.get_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.GetUserCredsRequest() + + assert args[0] == request_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_user_creds_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.list_user_creds), "__call__") as call: + client.list_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ListUserCredsRequest() + + assert args[0] == request_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_enable_user_creds_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.enable_user_creds), "__call__" + ) as call: + client.enable_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.EnableUserCredsRequest() + + assert args[0] == request_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_disable_user_creds_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.disable_user_creds), "__call__" + ) as call: + client.disable_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DisableUserCredsRequest() + + assert args[0] == request_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_reset_user_password_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.reset_user_password), "__call__" + ) as call: + client.reset_user_password(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.ResetUserPasswordRequest() + + assert args[0] == request_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_user_creds_empty_call_rest(): + client = FirestoreAdminClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_user_creds), "__call__" + ) as call: + client.delete_user_creds(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = firestore_admin.DeleteUserCredsRequest() + + assert args[0] == request_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_backup_empty_call_rest(): @@ -19588,6 +24799,13 @@ def test_firestore_admin_base_transport(): "list_databases", "update_database", "delete_database", + "create_user_creds", + "get_user_creds", + "list_user_creds", + "enable_user_creds", + "disable_user_creds", + "reset_user_password", + "delete_user_creds", "get_backup", "list_backups", "delete_backup", @@ -19921,6 +25139,27 @@ def test_firestore_admin_client_transport_session_collision(transport_name): session1 = client1.transport.delete_database._session session2 = client2.transport.delete_database._session assert session1 != session2 + session1 = client1.transport.create_user_creds._session + session2 = client2.transport.create_user_creds._session + assert session1 != session2 + session1 = client1.transport.get_user_creds._session + session2 = client2.transport.get_user_creds._session + assert session1 != session2 + session1 = client1.transport.list_user_creds._session + session2 = client2.transport.list_user_creds._session + assert session1 != session2 + session1 = client1.transport.enable_user_creds._session + session2 = client2.transport.enable_user_creds._session + assert session1 != session2 + session1 = client1.transport.disable_user_creds._session + session2 = client2.transport.disable_user_creds._session + assert session1 != session2 + session1 = client1.transport.reset_user_password._session + session2 = client2.transport.reset_user_password._session + assert session1 != session2 + session1 = client1.transport.delete_user_creds._session + session2 = client2.transport.delete_user_creds._session + assert session1 != session2 session1 = client1.transport.get_backup._session session2 = client2.transport.get_backup._session assert session1 != session2 @@ -20322,8 +25561,34 @@ def test_parse_operation_path(): assert expected == actual +def test_user_creds_path(): + project = "squid" + database = "clam" + user_creds = "whelk" + expected = "projects/{project}/databases/{database}/userCreds/{user_creds}".format( + project=project, + database=database, + user_creds=user_creds, + ) + actual = FirestoreAdminClient.user_creds_path(project, database, user_creds) + assert expected == actual + + +def test_parse_user_creds_path(): + expected = { + "project": "octopus", + "database": "oyster", + "user_creds": "nudibranch", + } + path = FirestoreAdminClient.user_creds_path(**expected) + + # Check that the path construction is reversible. + actual = FirestoreAdminClient.parse_user_creds_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, ) @@ -20333,7 +25598,7 @@ def test_common_billing_account_path(): def test_parse_common_billing_account_path(): expected = { - "billing_account": "clam", + "billing_account": "mussel", } path = FirestoreAdminClient.common_billing_account_path(**expected) @@ -20343,7 +25608,7 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): - folder = "whelk" + folder = "winkle" expected = "folders/{folder}".format( folder=folder, ) @@ -20353,7 +25618,7 @@ def test_common_folder_path(): def test_parse_common_folder_path(): expected = { - "folder": "octopus", + "folder": "nautilus", } path = FirestoreAdminClient.common_folder_path(**expected) @@ -20363,7 +25628,7 @@ def test_parse_common_folder_path(): def test_common_organization_path(): - organization = "oyster" + organization = "scallop" expected = "organizations/{organization}".format( organization=organization, ) @@ -20373,7 +25638,7 @@ def test_common_organization_path(): def test_parse_common_organization_path(): expected = { - "organization": "nudibranch", + "organization": "abalone", } path = FirestoreAdminClient.common_organization_path(**expected) @@ -20383,7 +25648,7 @@ def test_parse_common_organization_path(): def test_common_project_path(): - project = "cuttlefish" + project = "squid" expected = "projects/{project}".format( project=project, ) @@ -20393,7 +25658,7 @@ def test_common_project_path(): def test_parse_common_project_path(): expected = { - "project": "mussel", + "project": "clam", } path = FirestoreAdminClient.common_project_path(**expected) @@ -20403,8 +25668,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, @@ -20415,8 +25680,8 @@ def test_common_location_path(): def test_parse_common_location_path(): expected = { - "project": "scallop", - "location": "abalone", + "project": "oyster", + "location": "nudibranch", } path = FirestoreAdminClient.common_location_path(**expected) From 043d9ef59627e5ed7f1acb5ab0c9d47dfd2178c1 Mon Sep 17 00:00:00 2001 From: Jeff Verkoeyen Date: Tue, 20 May 2025 17:37:28 -0700 Subject: [PATCH 2/8] fix: Add missing DocumentReference return value to .document (#1053) --- google/cloud/firestore_v1/base_collection.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/google/cloud/firestore_v1/base_collection.py b/google/cloud/firestore_v1/base_collection.py index b74ced2a38..b113da827b 100644 --- a/google/cloud/firestore_v1/base_collection.py +++ b/google/cloud/firestore_v1/base_collection.py @@ -128,7 +128,7 @@ def _aggregation_query(self) -> BaseAggregationQuery: def _vector_query(self) -> BaseVectorQuery: raise NotImplementedError - def document(self, document_id: Optional[str] = None): + def document(self, document_id: Optional[str] = None) -> DocumentReference: """Create a sub-document underneath the current collection. Args: From 5a279b2bf514c95d1399212b8dec8e24dada4d2d Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Wed, 21 May 2025 06:35:29 -0400 Subject: [PATCH 3/8] chore: Update gapic-generator-python to 1.25.0 (#1043) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * chore: Update gapic-generator-python to 1.25.0 PiperOrigin-RevId: 755914147 Source-Link: https://github.com/googleapis/googleapis/commit/97a83d76a09a7f6dcab43675c87bdfeb5bcf1cb5 Source-Link: https://github.com/googleapis/googleapis-gen/commit/a9977efedc836ccece1f01d529b0315e1efe52ad Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiYTk5NzdlZmVkYzgzNmNjZWNlMWYwMWQ1MjliMDMxNWUxZWZlNTJhZCJ9 * πŸ¦‰ Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md --------- Co-authored-by: Owl Bot --- .../services/firestore_admin/async_client.py | 4 ++++ .../firestore_admin_v1/services/firestore_admin/client.py | 3 +++ .../services/firestore_admin/transports/base.py | 4 ++++ .../services/firestore_admin/transports/rest.py | 4 ++++ google/cloud/firestore_v1/services/firestore/async_client.py | 4 ++++ google/cloud/firestore_v1/services/firestore/client.py | 3 +++ .../cloud/firestore_v1/services/firestore/transports/base.py | 4 ++++ .../cloud/firestore_v1/services/firestore/transports/rest.py | 4 ++++ 8 files changed, 30 insertions(+) diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py b/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py index b7b4f67e7e..56531fa29a 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/async_client.py @@ -37,6 +37,7 @@ from google.api_core import retry_async as retries from google.auth import credentials as ga_credentials # type: ignore from google.oauth2 import service_account # type: ignore +import google.protobuf try: @@ -4342,5 +4343,8 @@ async def __aexit__(self, exc_type, exc, tb): gapic_version=package_version.__version__ ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + __all__ = ("FirestoreAdminAsyncClient",) diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/client.py b/google/cloud/firestore_admin_v1/services/firestore_admin/client.py index 3774fa7f22..d05b82787d 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/client.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/client.py @@ -45,6 +45,7 @@ from google.auth.transport.grpc import SslCredentials # type: ignore from google.auth.exceptions import MutualTLSChannelError # type: ignore from google.oauth2 import service_account # type: ignore +import google.protobuf try: OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] @@ -4837,5 +4838,7 @@ def cancel_operation( gapic_version=package_version.__version__ ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ __all__ = ("FirestoreAdminClient",) diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py index d866350130..f290fcbfe1 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/base.py @@ -26,6 +26,7 @@ from google.api_core import operations_v1 from google.auth import credentials as ga_credentials # type: ignore from google.oauth2 import service_account # type: ignore +import google.protobuf from google.cloud.firestore_admin_v1.types import backup from google.cloud.firestore_admin_v1.types import database @@ -43,6 +44,9 @@ gapic_version=package_version.__version__ ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + class FirestoreAdminTransport(abc.ABC): """Abstract transport class for FirestoreAdmin.""" diff --git a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py index 06ee1b9e3c..c96be2e329 100644 --- a/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py +++ b/google/cloud/firestore_admin_v1/services/firestore_admin/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +import google.protobuf from google.protobuf import json_format from google.api_core import operations_v1 @@ -69,6 +70,9 @@ rest_version=f"requests@{requests_version}", ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + class FirestoreAdminRestInterceptor: """Interceptor for FirestoreAdmin. diff --git a/google/cloud/firestore_v1/services/firestore/async_client.py b/google/cloud/firestore_v1/services/firestore/async_client.py index 56cf7d3af3..b904229b04 100644 --- a/google/cloud/firestore_v1/services/firestore/async_client.py +++ b/google/cloud/firestore_v1/services/firestore/async_client.py @@ -40,6 +40,7 @@ from google.api_core import retry_async as retries from google.auth import credentials as ga_credentials # type: ignore from google.oauth2 import service_account # type: ignore +import google.protobuf try: @@ -2198,5 +2199,8 @@ async def __aexit__(self, exc_type, exc, tb): gapic_version=package_version.__version__ ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + __all__ = ("FirestoreAsyncClient",) diff --git a/google/cloud/firestore_v1/services/firestore/client.py b/google/cloud/firestore_v1/services/firestore/client.py index 1fb800e616..8055612429 100644 --- a/google/cloud/firestore_v1/services/firestore/client.py +++ b/google/cloud/firestore_v1/services/firestore/client.py @@ -47,6 +47,7 @@ from google.auth.transport.grpc import SslCredentials # type: ignore from google.auth.exceptions import MutualTLSChannelError # type: ignore from google.oauth2 import service_account # type: ignore +import google.protobuf try: OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None] @@ -2585,5 +2586,7 @@ def cancel_operation( gapic_version=package_version.__version__ ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ __all__ = ("FirestoreClient",) diff --git a/google/cloud/firestore_v1/services/firestore/transports/base.py b/google/cloud/firestore_v1/services/firestore/transports/base.py index 862b098d1b..66d81748cd 100644 --- a/google/cloud/firestore_v1/services/firestore/transports/base.py +++ b/google/cloud/firestore_v1/services/firestore/transports/base.py @@ -25,6 +25,7 @@ from google.api_core import retry as retries from google.auth import credentials as ga_credentials # type: ignore from google.oauth2 import service_account # type: ignore +import google.protobuf from google.cloud.firestore_v1.types import document from google.cloud.firestore_v1.types import document as gf_document @@ -37,6 +38,9 @@ gapic_version=package_version.__version__ ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + class FirestoreTransport(abc.ABC): """Abstract transport class for Firestore.""" diff --git a/google/cloud/firestore_v1/services/firestore/transports/rest.py b/google/cloud/firestore_v1/services/firestore/transports/rest.py index 3794ecea38..8c038348c7 100644 --- a/google/cloud/firestore_v1/services/firestore/transports/rest.py +++ b/google/cloud/firestore_v1/services/firestore/transports/rest.py @@ -23,6 +23,7 @@ from google.api_core import rest_helpers from google.api_core import rest_streaming from google.api_core import gapic_v1 +import google.protobuf from google.protobuf import json_format from google.cloud.location import locations_pb2 # type: ignore @@ -63,6 +64,9 @@ rest_version=f"requests@{requests_version}", ) +if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER + DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__ + class FirestoreRestInterceptor: """Interceptor for Firestore. From f8bf2afaf5f20c064c036f06c3a10b18896bd8f2 Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Thu, 22 May 2025 16:16:19 -0700 Subject: [PATCH 4/8] chore: add java 21 to fix emulator tests (#1056) --- .github/workflows/system_emulated.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.github/workflows/system_emulated.yml b/.github/workflows/system_emulated.yml index 66f4367a68..0f3a69224b 100644 --- a/.github/workflows/system_emulated.yml +++ b/.github/workflows/system_emulated.yml @@ -19,6 +19,13 @@ jobs: with: python-version: '3.7' + # firestore emulator requires java 21+ + - name: Setup Java + uses: actions/setup-java@v4 + with: + distribution: temurin + java-version: '21' + - name: Setup GCloud SDK uses: google-github-actions/setup-gcloud@v2.1.1 From b01a03c6f5430016be48c8ec7dc10bc78e9b82d9 Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Thu, 22 May 2025 17:42:51 -0700 Subject: [PATCH 5/8] chore(tests): system test for unicode characters (#1003) --- tests/system/test_system.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/tests/system/test_system.py b/tests/system/test_system.py index d82d5113fa..b96ed04715 100644 --- a/tests/system/test_system.py +++ b/tests/system/test_system.py @@ -1072,6 +1072,33 @@ def test_collection_add(client, cleanup, database): assert set(collection3.list_documents()) == {document_ref5} +@pytest.mark.parametrize("database", [None, FIRESTORE_OTHER_DB], indirect=True) +def test_unicode_doc(client, cleanup, database): + collection_id = "coll-unicode" + UNIQUE_RESOURCE_ID + collection = client.collection(collection_id) + explicit_doc_id = "中逐" + UNIQUE_RESOURCE_ID + + assert set(collection.list_documents()) == set() + + data = {"baz": 0} + update_time, document_ref = collection.add(data, document_id=explicit_doc_id) + cleanup(document_ref.delete) + assert set(collection.list_documents()) == {document_ref, document_ref} + snapshot = document_ref.get() + assert snapshot.to_dict() == data + assert snapshot.create_time == update_time + assert snapshot.update_time == update_time + assert document_ref.id == explicit_doc_id + assert snapshot.reference.id == explicit_doc_id + + # update doc + data2 = {"baz": 9} + snapshot.reference.update(data2) + snapshot2 = document_ref.get() + assert snapshot2.to_dict() == data2 + assert snapshot2.reference.id == explicit_doc_id + + @pytest.fixture def query_docs(client, database): collection_id = "qs" + UNIQUE_RESOURCE_ID From 6c8162685eb82fc6f814f69741a2a51ddda4c2fa Mon Sep 17 00:00:00 2001 From: Jing Date: Fri, 23 May 2025 09:46:58 -0700 Subject: [PATCH 6/8] feat: Support Sequence[float] as query_vector in FindNearest (#908) --- google/cloud/firestore_v1/base_collection.py | 7 ++- google/cloud/firestore_v1/base_query.py | 3 +- .../cloud/firestore_v1/base_vector_query.py | 11 ++-- google/cloud/firestore_v1/query.py | 16 ++++- tests/unit/v1/test_vector.py | 4 +- tests/unit/v1/test_vector_query.py | 62 +++++++++++++++++++ 6 files changed, 90 insertions(+), 13 deletions(-) diff --git a/google/cloud/firestore_v1/base_collection.py b/google/cloud/firestore_v1/base_collection.py index b113da827b..0e5ae6ed1e 100644 --- a/google/cloud/firestore_v1/base_collection.py +++ b/google/cloud/firestore_v1/base_collection.py @@ -25,9 +25,10 @@ Generator, Generic, Iterable, - Optional, + Sequence, Tuple, Union, + Optional, ) from google.api_core import retry as retries @@ -555,7 +556,7 @@ def avg(self, field_ref: str | FieldPath, alias=None): def find_nearest( self, vector_field: str, - query_vector: Vector, + query_vector: Union[Vector, Sequence[float]], limit: int, distance_measure: DistanceMeasure, *, @@ -568,7 +569,7 @@ def find_nearest( Args: vector_field (str): An indexed vector field to search upon. Only documents which contain vectors whose dimensionality match the query_vector can be returned. - query_vector (Vector): The query vector that we are searching on. Must be a vector of no more + query_vector(Union[Vector, Sequence[float]]): The query vector that we are searching on. Must be a vector of no more than 2048 dimensions. limit (int): The number of nearest neighbors to return. Must be a positive integer of no more than 1000. distance_measure (:class:`DistanceMeasure`): The Distance Measure to use. diff --git a/google/cloud/firestore_v1/base_query.py b/google/cloud/firestore_v1/base_query.py index 5a9efaf783..2fb9bd895d 100644 --- a/google/cloud/firestore_v1/base_query.py +++ b/google/cloud/firestore_v1/base_query.py @@ -32,6 +32,7 @@ Iterable, List, Optional, + Sequence, Tuple, Type, Union, @@ -1000,7 +1001,7 @@ def _to_protobuf(self) -> StructuredQuery: def find_nearest( self, vector_field: str, - query_vector: Vector, + query_vector: Union[Vector, Sequence[float]], limit: int, distance_measure: DistanceMeasure, *, diff --git a/google/cloud/firestore_v1/base_vector_query.py b/google/cloud/firestore_v1/base_vector_query.py index f5a4403c81..88e40635f9 100644 --- a/google/cloud/firestore_v1/base_vector_query.py +++ b/google/cloud/firestore_v1/base_vector_query.py @@ -19,13 +19,14 @@ import abc from abc import ABC from enum import Enum -from typing import TYPE_CHECKING, Any, Coroutine, Optional, Tuple, Union +from typing import TYPE_CHECKING, Any, Coroutine, Optional, Sequence, Tuple, Union from google.api_core import gapic_v1 from google.api_core import retry as retries from google.cloud.firestore_v1 import _helpers from google.cloud.firestore_v1.types import query +from google.cloud.firestore_v1.vector import Vector if TYPE_CHECKING: # pragma: NO COVER from google.cloud.firestore_v1.async_stream_generator import AsyncStreamGenerator @@ -33,7 +34,6 @@ from google.cloud.firestore_v1.query_profile import ExplainOptions from google.cloud.firestore_v1.query_results import QueryResultsList from google.cloud.firestore_v1.stream_generator import StreamGenerator - from google.cloud.firestore_v1.vector import Vector class DistanceMeasure(Enum): @@ -137,7 +137,7 @@ def get( def find_nearest( self, vector_field: str, - query_vector: Vector, + query_vector: Union[Vector, Sequence[float]], limit: int, distance_measure: DistanceMeasure, *, @@ -145,8 +145,11 @@ def find_nearest( distance_threshold: Optional[float] = None, ): """Finds the closest vector embeddings to the given query vector.""" + if not isinstance(query_vector, Vector): + self._query_vector = Vector(query_vector) + else: + self._query_vector = query_vector self._vector_field = vector_field - self._query_vector = query_vector self._limit = limit self._distance_measure = distance_measure self._distance_result_field = distance_result_field diff --git a/google/cloud/firestore_v1/query.py b/google/cloud/firestore_v1/query.py index 0b52afc834..a8b821bdc4 100644 --- a/google/cloud/firestore_v1/query.py +++ b/google/cloud/firestore_v1/query.py @@ -20,7 +20,17 @@ """ from __future__ import annotations -from typing import TYPE_CHECKING, Any, Callable, Generator, List, Optional, Type +from typing import ( + TYPE_CHECKING, + Any, + Callable, + Generator, + List, + Optional, + Sequence, + Type, + Union, +) from google.api_core import exceptions, gapic_v1 from google.api_core import retry as retries @@ -269,7 +279,7 @@ def _retry_query_after_exception(self, exc, retry, transaction): def find_nearest( self, vector_field: str, - query_vector: Vector, + query_vector: Union[Vector, Sequence[float]], limit: int, distance_measure: DistanceMeasure, *, @@ -282,7 +292,7 @@ def find_nearest( Args: vector_field (str): An indexed vector field to search upon. Only documents which contain vectors whose dimensionality match the query_vector can be returned. - query_vector (Vector): The query vector that we are searching on. Must be a vector of no more + query_vector(Vector | Sequence[float]): The query vector that we are searching on. Must be a vector of no more than 2048 dimensions. limit (int): The number of nearest neighbors to return. Must be a positive integer of no more than 1000. distance_measure (:class:`DistanceMeasure`): The Distance Measure to use. diff --git a/tests/unit/v1/test_vector.py b/tests/unit/v1/test_vector.py index a28a055253..d850fc1cfd 100644 --- a/tests/unit/v1/test_vector.py +++ b/tests/unit/v1/test_vector.py @@ -25,7 +25,7 @@ from google.cloud.firestore_v1.vector import Vector -def _make_commit_repsonse(): +def _make_commit_response(): response = mock.create_autospec(firestore.CommitResponse) response.write_results = [mock.sentinel.write_result] response.commit_time = mock.sentinel.commit_time @@ -35,7 +35,7 @@ def _make_commit_repsonse(): def _make_firestore_api(): firestore_api = mock.Mock() firestore_api.commit.mock_add_spec(spec=["commit"]) - firestore_api.commit.return_value = _make_commit_repsonse() + firestore_api.commit.return_value = _make_commit_response() return firestore_api diff --git a/tests/unit/v1/test_vector_query.py b/tests/unit/v1/test_vector_query.py index eb5328ace6..ad88478c83 100644 --- a/tests/unit/v1/test_vector_query.py +++ b/tests/unit/v1/test_vector_query.py @@ -533,6 +533,68 @@ def test_vector_query_collection_group(distance_measure, expected_distance): ) +def test_vector_query_list_as_query_vector(): + # Create a minimal fake GAPIC. + firestore_api = mock.Mock(spec=["run_query"]) + client = make_client() + client._firestore_api_internal = firestore_api + + # Make a **real** collection reference as parent. + parent = client.collection("dee") + query = make_query(parent) + parent_path, expected_prefix = parent._parent_info() + + data = {"snooze": 10, "embedding": Vector([1.0, 2.0, 3.0])} + response_pb1 = _make_query_response( + name="{}/test_doc".format(expected_prefix), data=data + ) + response_pb2 = _make_query_response( + name="{}/test_doc".format(expected_prefix), data=data + ) + + kwargs = make_retry_timeout_kwargs(retry=None, timeout=None) + + # Execute the vector query and check the response. + firestore_api.run_query.return_value = iter([response_pb1, response_pb2]) + + vector_query = query.where("snooze", "==", 10).find_nearest( + vector_field="embedding", + query_vector=[1.0, 2.0, 3.0], + distance_measure=DistanceMeasure.EUCLIDEAN, + limit=5, + ) + + returned = vector_query.get(transaction=_transaction(client), **kwargs) + assert isinstance(returned, list) + assert len(returned) == 2 + assert returned[0].to_dict() == data + + expected_pb = _expected_pb( + parent=parent, + vector_field="embedding", + vector=Vector([1.0, 2.0, 3.0]), + distance_type=StructuredQuery.FindNearest.DistanceMeasure.EUCLIDEAN, + limit=5, + ) + expected_pb.where = StructuredQuery.Filter( + field_filter=StructuredQuery.FieldFilter( + field=StructuredQuery.FieldReference(field_path="snooze"), + op=StructuredQuery.FieldFilter.Operator.EQUAL, + value=encode_value(10), + ) + ) + + firestore_api.run_query.assert_called_once_with( + request={ + "parent": parent_path, + "structured_query": expected_pb, + "transaction": _TXN_ID, + }, + metadata=client._rpc_metadata, + **kwargs, + ) + + def test_query_stream_multiple_empty_response_in_stream(): from google.cloud.firestore_v1 import stream_generator From 0fb4f2d8f690f22a5c6ebaf882e5fb69416107d3 Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Fri, 23 May 2025 14:31:46 -0700 Subject: [PATCH 7/8] chore: update renovate.json (#1058) --- owlbot.py | 2 +- renovate.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/owlbot.py b/owlbot.py index a0b6cc8124..f08048fef7 100644 --- a/owlbot.py +++ b/owlbot.py @@ -147,7 +147,7 @@ def update_fixup_scripts(library): ) s.move(templated_files, - excludes=[".github/release-please.yml"]) + excludes=[".github/release-please.yml", "renovate.json"]) python.py_samples(skip_readmes=True) diff --git a/renovate.json b/renovate.json index c7875c469b..e2175ba2e8 100644 --- a/renovate.json +++ b/renovate.json @@ -5,7 +5,7 @@ ":preserveSemverRanges", ":disableDependencyDashboard" ], - "ignorePaths": [".pre-commit-config.yaml", ".kokoro/requirements.txt", "setup.py", ".github/workflows/unittest.yml"], + "ignorePaths": [".pre-commit-config.yaml", ".kokoro/requirements.txt", "setup.py", ".github/workflows/*"], "pip_requirements": { "fileMatch": ["requirements-test.txt", "samples/[\\S/]*constraints.txt", "samples/[\\S/]*constraints-test.txt"] } From 437e23309e5da9363352bda7c4e702886d2ef60d Mon Sep 17 00:00:00 2001 From: "release-please[bot]" <55107282+release-please[bot]@users.noreply.github.com> Date: Wed, 28 May 2025 09:56:14 -0700 Subject: [PATCH 8/8] chore(main): release 2.21.0 (#1055) Co-authored-by: release-please[bot] <55107282+release-please[bot]@users.noreply.github.com> --- .release-please-manifest.json | 2 +- CHANGELOG.md | 12 ++++++++++++ google/cloud/firestore/gapic_version.py | 2 +- google/cloud/firestore_admin_v1/gapic_version.py | 2 +- google/cloud/firestore_bundle/gapic_version.py | 2 +- google/cloud/firestore_v1/gapic_version.py | 2 +- 6 files changed, 17 insertions(+), 5 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index eeb4bcda33..5be20145ac 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "2.20.2" + ".": "2.21.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index b677942c7e..893a012978 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,18 @@ [1]: https://pypi.org/project/google-cloud-firestore/#history +## [2.21.0](https://github.com/googleapis/python-firestore/compare/v2.20.2...v2.21.0) (2025-05-23) + + +### Features + +* Support Sequence[float] as query_vector in FindNearest ([#908](https://github.com/googleapis/python-firestore/issues/908)) ([6c81626](https://github.com/googleapis/python-firestore/commit/6c8162685eb82fc6f814f69741a2a51ddda4c2fa)) + + +### Bug Fixes + +* Add missing DocumentReference return value to .document ([#1053](https://github.com/googleapis/python-firestore/issues/1053)) ([043d9ef](https://github.com/googleapis/python-firestore/commit/043d9ef59627e5ed7f1acb5ab0c9d47dfd2178c1)) + ## [2.20.2](https://github.com/googleapis/python-firestore/compare/v2.20.1...v2.20.2) (2025-04-14) diff --git a/google/cloud/firestore/gapic_version.py b/google/cloud/firestore/gapic_version.py index 4c1787c538..e546bae053 100644 --- a/google/cloud/firestore/gapic_version.py +++ b/google/cloud/firestore/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "2.20.2" # {x-release-please-version} +__version__ = "2.21.0" # {x-release-please-version} diff --git a/google/cloud/firestore_admin_v1/gapic_version.py b/google/cloud/firestore_admin_v1/gapic_version.py index 4c1787c538..e546bae053 100644 --- a/google/cloud/firestore_admin_v1/gapic_version.py +++ b/google/cloud/firestore_admin_v1/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "2.20.2" # {x-release-please-version} +__version__ = "2.21.0" # {x-release-please-version} diff --git a/google/cloud/firestore_bundle/gapic_version.py b/google/cloud/firestore_bundle/gapic_version.py index 4c1787c538..e546bae053 100644 --- a/google/cloud/firestore_bundle/gapic_version.py +++ b/google/cloud/firestore_bundle/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "2.20.2" # {x-release-please-version} +__version__ = "2.21.0" # {x-release-please-version} diff --git a/google/cloud/firestore_v1/gapic_version.py b/google/cloud/firestore_v1/gapic_version.py index 4c1787c538..e546bae053 100644 --- a/google/cloud/firestore_v1/gapic_version.py +++ b/google/cloud/firestore_v1/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "2.20.2" # {x-release-please-version} +__version__ = "2.21.0" # {x-release-please-version}