diff --git a/google/cloud/kms/__init__.py b/google/cloud/kms/__init__.py index c3ccdbac..295aed2b 100644 --- a/google/cloud/kms/__init__.py +++ b/google/cloud/kms/__init__.py @@ -29,10 +29,13 @@ from google.cloud.kms_v1.types.ekm_service import ( Certificate, CreateEkmConnectionRequest, + EkmConfig, EkmConnection, + GetEkmConfigRequest, GetEkmConnectionRequest, ListEkmConnectionsRequest, ListEkmConnectionsResponse, + UpdateEkmConfigRequest, UpdateEkmConnectionRequest, ) from google.cloud.kms_v1.types.resources import ( @@ -95,10 +98,13 @@ "KeyManagementServiceAsyncClient", "Certificate", "CreateEkmConnectionRequest", + "EkmConfig", "EkmConnection", + "GetEkmConfigRequest", "GetEkmConnectionRequest", "ListEkmConnectionsRequest", "ListEkmConnectionsResponse", + "UpdateEkmConfigRequest", "UpdateEkmConnectionRequest", "CryptoKey", "CryptoKeyVersion", diff --git a/google/cloud/kms_v1/__init__.py b/google/cloud/kms_v1/__init__.py index ea53b958..6f89ec6c 100644 --- a/google/cloud/kms_v1/__init__.py +++ b/google/cloud/kms_v1/__init__.py @@ -26,10 +26,13 @@ from .types.ekm_service import ( Certificate, CreateEkmConnectionRequest, + EkmConfig, EkmConnection, + GetEkmConfigRequest, GetEkmConnectionRequest, ListEkmConnectionsRequest, ListEkmConnectionsResponse, + UpdateEkmConfigRequest, UpdateEkmConnectionRequest, ) from .types.resources import ( @@ -105,6 +108,7 @@ "DecryptResponse", "DestroyCryptoKeyVersionRequest", "Digest", + "EkmConfig", "EkmConnection", "EkmServiceClient", "EncryptRequest", @@ -114,6 +118,7 @@ "GenerateRandomBytesResponse", "GetCryptoKeyRequest", "GetCryptoKeyVersionRequest", + "GetEkmConfigRequest", "GetEkmConnectionRequest", "GetImportJobRequest", "GetKeyRingRequest", @@ -144,5 +149,6 @@ "UpdateCryptoKeyPrimaryVersionRequest", "UpdateCryptoKeyRequest", "UpdateCryptoKeyVersionRequest", + "UpdateEkmConfigRequest", "UpdateEkmConnectionRequest", ) diff --git a/google/cloud/kms_v1/gapic_metadata.json b/google/cloud/kms_v1/gapic_metadata.json index 00dfdf5a..613eb488 100644 --- a/google/cloud/kms_v1/gapic_metadata.json +++ b/google/cloud/kms_v1/gapic_metadata.json @@ -15,6 +15,11 @@ "create_ekm_connection" ] }, + "GetEkmConfig": { + "methods": [ + "get_ekm_config" + ] + }, "GetEkmConnection": { "methods": [ "get_ekm_connection" @@ -25,6 +30,11 @@ "list_ekm_connections" ] }, + "UpdateEkmConfig": { + "methods": [ + "update_ekm_config" + ] + }, "UpdateEkmConnection": { "methods": [ "update_ekm_connection" @@ -40,6 +50,11 @@ "create_ekm_connection" ] }, + "GetEkmConfig": { + "methods": [ + "get_ekm_config" + ] + }, "GetEkmConnection": { "methods": [ "get_ekm_connection" @@ -50,6 +65,11 @@ "list_ekm_connections" ] }, + "UpdateEkmConfig": { + "methods": [ + "update_ekm_config" + ] + }, "UpdateEkmConnection": { "methods": [ "update_ekm_connection" @@ -65,6 +85,11 @@ "create_ekm_connection" ] }, + "GetEkmConfig": { + "methods": [ + "get_ekm_config" + ] + }, "GetEkmConnection": { "methods": [ "get_ekm_connection" @@ -75,6 +100,11 @@ "list_ekm_connections" ] }, + "UpdateEkmConfig": { + "methods": [ + "update_ekm_config" + ] + }, "UpdateEkmConnection": { "methods": [ "update_ekm_connection" diff --git a/google/cloud/kms_v1/services/ekm_service/async_client.py b/google/cloud/kms_v1/services/ekm_service/async_client.py index e7a166a8..d6cf2361 100644 --- a/google/cloud/kms_v1/services/ekm_service/async_client.py +++ b/google/cloud/kms_v1/services/ekm_service/async_client.py @@ -70,6 +70,8 @@ class EkmServiceAsyncClient: DEFAULT_ENDPOINT = EkmServiceClient.DEFAULT_ENDPOINT DEFAULT_MTLS_ENDPOINT = EkmServiceClient.DEFAULT_MTLS_ENDPOINT + ekm_config_path = staticmethod(EkmServiceClient.ekm_config_path) + parse_ekm_config_path = staticmethod(EkmServiceClient.parse_ekm_config_path) ekm_connection_path = staticmethod(EkmServiceClient.ekm_connection_path) parse_ekm_connection_path = staticmethod(EkmServiceClient.parse_ekm_connection_path) service_path = staticmethod(EkmServiceClient.service_path) @@ -756,6 +758,238 @@ async def sample_update_ekm_connection(): # Done; return the response. return response + async def get_ekm_config( + self, + request: Optional[Union[ekm_service.GetEkmConfigRequest, dict]] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> ekm_service.EkmConfig: + r"""Returns the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import kms_v1 + + async def sample_get_ekm_config(): + # Create a client + client = kms_v1.EkmServiceAsyncClient() + + # Initialize request argument(s) + request = kms_v1.GetEkmConfigRequest( + name="name_value", + ) + + # Make the request + response = await client.get_ekm_config(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.kms_v1.types.GetEkmConfigRequest, dict]]): + The request object. Request message for + [EkmService.GetEkmConfig][google.cloud.kms.v1.EkmService.GetEkmConfig]. + name (:class:`str`): + Required. The [name][google.cloud.kms.v1.EkmConfig.name] + of the [EkmConfig][google.cloud.kms.v1.EkmConfig] to + get. + + 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, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.cloud.kms_v1.types.EkmConfig: + An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a singleton resource that + represents configuration parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] + with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] + of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] + in a given project and location. + + """ + # 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. + has_flattened_params = any([name]) + 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." + ) + + request = ekm_service.GetEkmConfigRequest(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 = gapic_v1.method_async.wrap_method( + self._client._transport.get_ekm_config, + default_timeout=None, + client_info=DEFAULT_CLIENT_INFO, + ) + + # 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),)), + ) + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + async def update_ekm_config( + self, + request: Optional[Union[ekm_service.UpdateEkmConfigRequest, dict]] = None, + *, + ekm_config: Optional[ekm_service.EkmConfig] = None, + update_mask: Optional[field_mask_pb2.FieldMask] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> ekm_service.EkmConfig: + r"""Updates the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import kms_v1 + + async def sample_update_ekm_config(): + # Create a client + client = kms_v1.EkmServiceAsyncClient() + + # Initialize request argument(s) + request = kms_v1.UpdateEkmConfigRequest( + ) + + # Make the request + response = await client.update_ekm_config(request=request) + + # Handle the response + print(response) + + Args: + request (Optional[Union[google.cloud.kms_v1.types.UpdateEkmConfigRequest, dict]]): + The request object. Request message for + [EkmService.UpdateEkmConfig][google.cloud.kms.v1.EkmService.UpdateEkmConfig]. + ekm_config (:class:`google.cloud.kms_v1.types.EkmConfig`): + Required. [EkmConfig][google.cloud.kms.v1.EkmConfig] + with updated values. + + This corresponds to the ``ekm_config`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Required. List of fields to be + updated in this request. + + This corresponds to the ``update_mask`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.cloud.kms_v1.types.EkmConfig: + An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a singleton resource that + represents configuration parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] + with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] + of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] + in a given project and location. + + """ + # 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. + has_flattened_params = any([ekm_config, update_mask]) + 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." + ) + + request = ekm_service.UpdateEkmConfigRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if ekm_config is not None: + request.ekm_config = ekm_config + if update_mask is not None: + request.update_mask = update_mask + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.update_ekm_config, + default_timeout=None, + client_info=DEFAULT_CLIENT_INFO, + ) + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("ekm_config.name", request.ekm_config.name),) + ), + ) + + # Send the request. + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + async def get_location( self, request: Optional[locations_pb2.GetLocationRequest] = None, diff --git a/google/cloud/kms_v1/services/ekm_service/client.py b/google/cloud/kms_v1/services/ekm_service/client.py index 08f9da61..c5098fa7 100644 --- a/google/cloud/kms_v1/services/ekm_service/client.py +++ b/google/cloud/kms_v1/services/ekm_service/client.py @@ -187,6 +187,25 @@ def transport(self) -> EkmServiceTransport: """ return self._transport + @staticmethod + def ekm_config_path( + project: str, + location: str, + ) -> str: + """Returns a fully-qualified ekm_config string.""" + return "projects/{project}/locations/{location}/ekmConfig".format( + project=project, + location=location, + ) + + @staticmethod + def parse_ekm_config_path(path: str) -> Dict[str, str]: + """Parses a ekm_config path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/ekmConfig$", path + ) + return m.groupdict() if m else {} + @staticmethod def ekm_connection_path( project: str, @@ -971,6 +990,238 @@ def sample_update_ekm_connection(): # Done; return the response. return response + def get_ekm_config( + self, + request: Optional[Union[ekm_service.GetEkmConfigRequest, dict]] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> ekm_service.EkmConfig: + r"""Returns the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import kms_v1 + + def sample_get_ekm_config(): + # Create a client + client = kms_v1.EkmServiceClient() + + # Initialize request argument(s) + request = kms_v1.GetEkmConfigRequest( + name="name_value", + ) + + # Make the request + response = client.get_ekm_config(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.kms_v1.types.GetEkmConfigRequest, dict]): + The request object. Request message for + [EkmService.GetEkmConfig][google.cloud.kms.v1.EkmService.GetEkmConfig]. + name (str): + Required. The [name][google.cloud.kms.v1.EkmConfig.name] + of the [EkmConfig][google.cloud.kms.v1.EkmConfig] to + get. + + 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, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.cloud.kms_v1.types.EkmConfig: + An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a singleton resource that + represents configuration parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] + with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] + of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] + in a given project and location. + + """ + # 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. + has_flattened_params = any([name]) + 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." + ) + + # Minor optimization to avoid making a copy if the user passes + # in a ekm_service.GetEkmConfigRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, ekm_service.GetEkmConfigRequest): + request = ekm_service.GetEkmConfigRequest(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_ekm_config] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), + ) + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + + def update_ekm_config( + self, + request: Optional[Union[ekm_service.UpdateEkmConfigRequest, dict]] = None, + *, + ekm_config: Optional[ekm_service.EkmConfig] = None, + update_mask: Optional[field_mask_pb2.FieldMask] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, str]] = (), + ) -> ekm_service.EkmConfig: + r"""Updates the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.cloud import kms_v1 + + def sample_update_ekm_config(): + # Create a client + client = kms_v1.EkmServiceClient() + + # Initialize request argument(s) + request = kms_v1.UpdateEkmConfigRequest( + ) + + # Make the request + response = client.update_ekm_config(request=request) + + # Handle the response + print(response) + + Args: + request (Union[google.cloud.kms_v1.types.UpdateEkmConfigRequest, dict]): + The request object. Request message for + [EkmService.UpdateEkmConfig][google.cloud.kms.v1.EkmService.UpdateEkmConfig]. + ekm_config (google.cloud.kms_v1.types.EkmConfig): + Required. [EkmConfig][google.cloud.kms.v1.EkmConfig] + with updated values. + + This corresponds to the ``ekm_config`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. List of fields to be + updated in this request. + + This corresponds to the ``update_mask`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.cloud.kms_v1.types.EkmConfig: + An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a singleton resource that + represents configuration parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] + with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] + of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] + in a given project and location. + + """ + # 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. + has_flattened_params = any([ekm_config, update_mask]) + 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." + ) + + # Minor optimization to avoid making a copy if the user passes + # in a ekm_service.UpdateEkmConfigRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, ekm_service.UpdateEkmConfigRequest): + request = ekm_service.UpdateEkmConfigRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if ekm_config is not None: + request.ekm_config = ekm_config + if update_mask is not None: + request.update_mask = update_mask + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.update_ekm_config] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("ekm_config.name", request.ekm_config.name),) + ), + ) + + # Send the request. + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + + # Done; return the response. + return response + def __enter__(self) -> "EkmServiceClient": return self diff --git a/google/cloud/kms_v1/services/ekm_service/transports/base.py b/google/cloud/kms_v1/services/ekm_service/transports/base.py index 1c03a485..4c472404 100644 --- a/google/cloud/kms_v1/services/ekm_service/transports/base.py +++ b/google/cloud/kms_v1/services/ekm_service/transports/base.py @@ -188,6 +188,16 @@ def _prep_wrapped_messages(self, client_info): default_timeout=60.0, client_info=client_info, ), + self.get_ekm_config: gapic_v1.method.wrap_method( + self.get_ekm_config, + default_timeout=None, + client_info=client_info, + ), + self.update_ekm_config: gapic_v1.method.wrap_method( + self.update_ekm_config, + default_timeout=None, + client_info=client_info, + ), } def close(self): @@ -238,6 +248,24 @@ def update_ekm_connection( ]: raise NotImplementedError() + @property + def get_ekm_config( + self, + ) -> Callable[ + [ekm_service.GetEkmConfigRequest], + Union[ekm_service.EkmConfig, Awaitable[ekm_service.EkmConfig]], + ]: + raise NotImplementedError() + + @property + def update_ekm_config( + self, + ) -> Callable[ + [ekm_service.UpdateEkmConfigRequest], + Union[ekm_service.EkmConfig, Awaitable[ekm_service.EkmConfig]], + ]: + raise NotImplementedError() + @property def get_location( self, diff --git a/google/cloud/kms_v1/services/ekm_service/transports/grpc.py b/google/cloud/kms_v1/services/ekm_service/transports/grpc.py index b94addea..952197d3 100644 --- a/google/cloud/kms_v1/services/ekm_service/transports/grpc.py +++ b/google/cloud/kms_v1/services/ekm_service/transports/grpc.py @@ -345,6 +345,60 @@ def update_ekm_connection( ) return self._stubs["update_ekm_connection"] + @property + def get_ekm_config( + self, + ) -> Callable[[ekm_service.GetEkmConfigRequest], ekm_service.EkmConfig]: + r"""Return a callable for the get ekm config method over gRPC. + + Returns the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + Returns: + Callable[[~.GetEkmConfigRequest], + ~.EkmConfig]: + 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_ekm_config" not in self._stubs: + self._stubs["get_ekm_config"] = self.grpc_channel.unary_unary( + "/google.cloud.kms.v1.EkmService/GetEkmConfig", + request_serializer=ekm_service.GetEkmConfigRequest.serialize, + response_deserializer=ekm_service.EkmConfig.deserialize, + ) + return self._stubs["get_ekm_config"] + + @property + def update_ekm_config( + self, + ) -> Callable[[ekm_service.UpdateEkmConfigRequest], ekm_service.EkmConfig]: + r"""Return a callable for the update ekm config method over gRPC. + + Updates the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + Returns: + Callable[[~.UpdateEkmConfigRequest], + ~.EkmConfig]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "update_ekm_config" not in self._stubs: + self._stubs["update_ekm_config"] = self.grpc_channel.unary_unary( + "/google.cloud.kms.v1.EkmService/UpdateEkmConfig", + request_serializer=ekm_service.UpdateEkmConfigRequest.serialize, + response_deserializer=ekm_service.EkmConfig.deserialize, + ) + return self._stubs["update_ekm_config"] + @property def set_iam_policy( self, diff --git a/google/cloud/kms_v1/services/ekm_service/transports/grpc_asyncio.py b/google/cloud/kms_v1/services/ekm_service/transports/grpc_asyncio.py index 54030e4d..9b87d3ae 100644 --- a/google/cloud/kms_v1/services/ekm_service/transports/grpc_asyncio.py +++ b/google/cloud/kms_v1/services/ekm_service/transports/grpc_asyncio.py @@ -355,6 +355,62 @@ def update_ekm_connection( ) return self._stubs["update_ekm_connection"] + @property + def get_ekm_config( + self, + ) -> Callable[[ekm_service.GetEkmConfigRequest], Awaitable[ekm_service.EkmConfig]]: + r"""Return a callable for the get ekm config method over gRPC. + + Returns the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + Returns: + Callable[[~.GetEkmConfigRequest], + Awaitable[~.EkmConfig]]: + 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_ekm_config" not in self._stubs: + self._stubs["get_ekm_config"] = self.grpc_channel.unary_unary( + "/google.cloud.kms.v1.EkmService/GetEkmConfig", + request_serializer=ekm_service.GetEkmConfigRequest.serialize, + response_deserializer=ekm_service.EkmConfig.deserialize, + ) + return self._stubs["get_ekm_config"] + + @property + def update_ekm_config( + self, + ) -> Callable[ + [ekm_service.UpdateEkmConfigRequest], Awaitable[ekm_service.EkmConfig] + ]: + r"""Return a callable for the update ekm config method over gRPC. + + Updates the [EkmConfig][google.cloud.kms.v1.EkmConfig] singleton + resource for a given project and location. + + Returns: + Callable[[~.UpdateEkmConfigRequest], + Awaitable[~.EkmConfig]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "update_ekm_config" not in self._stubs: + self._stubs["update_ekm_config"] = self.grpc_channel.unary_unary( + "/google.cloud.kms.v1.EkmService/UpdateEkmConfig", + request_serializer=ekm_service.UpdateEkmConfigRequest.serialize, + response_deserializer=ekm_service.EkmConfig.deserialize, + ) + return self._stubs["update_ekm_config"] + @property def set_iam_policy( self, diff --git a/google/cloud/kms_v1/services/ekm_service/transports/rest.py b/google/cloud/kms_v1/services/ekm_service/transports/rest.py index 638073ed..9122af04 100644 --- a/google/cloud/kms_v1/services/ekm_service/transports/rest.py +++ b/google/cloud/kms_v1/services/ekm_service/transports/rest.py @@ -77,6 +77,14 @@ def post_create_ekm_connection(self, response): logging.log(f"Received response: {response}") return response + def pre_get_ekm_config(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_ekm_config(self, response): + logging.log(f"Received response: {response}") + return response + def pre_get_ekm_connection(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -93,6 +101,14 @@ def post_list_ekm_connections(self, response): logging.log(f"Received response: {response}") return response + def pre_update_ekm_config(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_ekm_config(self, response): + logging.log(f"Received response: {response}") + return response + def pre_update_ekm_connection(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -130,6 +146,29 @@ def post_create_ekm_connection( """ return response + def pre_get_ekm_config( + self, + request: ekm_service.GetEkmConfigRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[ekm_service.GetEkmConfigRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_ekm_config + + Override in a subclass to manipulate the request or metadata + before they are sent to the EkmService server. + """ + return request, metadata + + def post_get_ekm_config( + self, response: ekm_service.EkmConfig + ) -> ekm_service.EkmConfig: + """Post-rpc interceptor for get_ekm_config + + Override in a subclass to manipulate the response + after it is returned by the EkmService server but before + it is returned to user code. + """ + return response + def pre_get_ekm_connection( self, request: ekm_service.GetEkmConnectionRequest, @@ -176,6 +215,29 @@ def post_list_ekm_connections( """ return response + def pre_update_ekm_config( + self, + request: ekm_service.UpdateEkmConfigRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[ekm_service.UpdateEkmConfigRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for update_ekm_config + + Override in a subclass to manipulate the request or metadata + before they are sent to the EkmService server. + """ + return request, metadata + + def post_update_ekm_config( + self, response: ekm_service.EkmConfig + ) -> ekm_service.EkmConfig: + """Post-rpc interceptor for update_ekm_config + + Override in a subclass to manipulate the response + after it is returned by the EkmService server but before + it is returned to user code. + """ + return response + def pre_update_ekm_connection( self, request: ekm_service.UpdateEkmConnectionRequest, @@ -525,6 +587,104 @@ def __call__( resp = self._interceptor.post_create_ekm_connection(resp) return resp + class _GetEkmConfig(EkmServiceRestStub): + def __hash__(self): + return hash("GetEkmConfig") + + __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 + } + + def __call__( + self, + request: ekm_service.GetEkmConfigRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> ekm_service.EkmConfig: + r"""Call the get ekm config method over HTTP. + + Args: + request (~.ekm_service.GetEkmConfigRequest): + The request object. Request message for + [EkmService.GetEkmConfig][google.cloud.kms.v1.EkmService.GetEkmConfig]. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.ekm_service.EkmConfig: + An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a + singleton resource that represents configuration + parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] + with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] + of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] + in a given project and location. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/ekmConfig}", + }, + ] + request, metadata = self._interceptor.pre_get_ekm_config(request, metadata) + pb_request = ekm_service.GetEkmConfigRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=True, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + query_params["$alt"] = "json;enum-encoding=int" + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = ekm_service.EkmConfig() + pb_resp = ekm_service.EkmConfig.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_ekm_config(resp) + return resp + class _GetEkmConnection(EkmServiceRestStub): def __hash__(self): return hash("GetEkmConnection") @@ -719,6 +879,117 @@ def __call__( resp = self._interceptor.post_list_ekm_connections(resp) return resp + class _UpdateEkmConfig(EkmServiceRestStub): + def __hash__(self): + return hash("UpdateEkmConfig") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = { + "updateMask": {}, + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: ekm_service.UpdateEkmConfigRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> ekm_service.EkmConfig: + r"""Call the update ekm config method over HTTP. + + Args: + request (~.ekm_service.UpdateEkmConfigRequest): + The request object. Request message for + [EkmService.UpdateEkmConfig][google.cloud.kms.v1.EkmService.UpdateEkmConfig]. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.ekm_service.EkmConfig: + An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a + singleton resource that represents configuration + parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] + with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] + of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] + in a given project and location. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "patch", + "uri": "/v1/{ekm_config.name=projects/*/locations/*/ekmConfig}", + "body": "ekm_config", + }, + ] + request, metadata = self._interceptor.pre_update_ekm_config( + request, metadata + ) + pb_request = ekm_service.UpdateEkmConfigRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=True, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=True, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + query_params["$alt"] = "json;enum-encoding=int" + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=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 = ekm_service.EkmConfig() + pb_resp = ekm_service.EkmConfig.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_update_ekm_config(resp) + return resp + class _UpdateEkmConnection(EkmServiceRestStub): def __hash__(self): return hash("UpdateEkmConnection") @@ -840,6 +1111,14 @@ def create_ekm_connection( # In C++ this would require a dynamic_cast return self._CreateEkmConnection(self._session, self._host, self._interceptor) # type: ignore + @property + def get_ekm_config( + self, + ) -> Callable[[ekm_service.GetEkmConfigRequest], ekm_service.EkmConfig]: + # 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._GetEkmConfig(self._session, self._host, self._interceptor) # type: ignore + @property def get_ekm_connection( self, @@ -858,6 +1137,14 @@ def list_ekm_connections( # In C++ this would require a dynamic_cast return self._ListEkmConnections(self._session, self._host, self._interceptor) # type: ignore + @property + def update_ekm_config( + self, + ) -> Callable[[ekm_service.UpdateEkmConfigRequest], ekm_service.EkmConfig]: + # 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._UpdateEkmConfig(self._session, self._host, self._interceptor) # type: ignore + @property def update_ekm_connection( self, diff --git a/google/cloud/kms_v1/types/__init__.py b/google/cloud/kms_v1/types/__init__.py index a634be01..35d730b9 100644 --- a/google/cloud/kms_v1/types/__init__.py +++ b/google/cloud/kms_v1/types/__init__.py @@ -16,10 +16,13 @@ from .ekm_service import ( Certificate, CreateEkmConnectionRequest, + EkmConfig, EkmConnection, + GetEkmConfigRequest, GetEkmConnectionRequest, ListEkmConnectionsRequest, ListEkmConnectionsResponse, + UpdateEkmConfigRequest, UpdateEkmConnectionRequest, ) from .resources import ( @@ -78,10 +81,13 @@ __all__ = ( "Certificate", "CreateEkmConnectionRequest", + "EkmConfig", "EkmConnection", + "GetEkmConfigRequest", "GetEkmConnectionRequest", "ListEkmConnectionsRequest", "ListEkmConnectionsResponse", + "UpdateEkmConfigRequest", "UpdateEkmConnectionRequest", "CryptoKey", "CryptoKeyVersion", diff --git a/google/cloud/kms_v1/types/ekm_service.py b/google/cloud/kms_v1/types/ekm_service.py index 4499f2af..3a7f0720 100644 --- a/google/cloud/kms_v1/types/ekm_service.py +++ b/google/cloud/kms_v1/types/ekm_service.py @@ -29,8 +29,11 @@ "GetEkmConnectionRequest", "CreateEkmConnectionRequest", "UpdateEkmConnectionRequest", + "GetEkmConfigRequest", + "UpdateEkmConfigRequest", "Certificate", "EkmConnection", + "EkmConfig", }, ) @@ -202,6 +205,47 @@ class UpdateEkmConnectionRequest(proto.Message): ) +class GetEkmConfigRequest(proto.Message): + r"""Request message for + [EkmService.GetEkmConfig][google.cloud.kms.v1.EkmService.GetEkmConfig]. + + Attributes: + name (str): + Required. The [name][google.cloud.kms.v1.EkmConfig.name] of + the [EkmConfig][google.cloud.kms.v1.EkmConfig] to get. + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + + +class UpdateEkmConfigRequest(proto.Message): + r"""Request message for + [EkmService.UpdateEkmConfig][google.cloud.kms.v1.EkmService.UpdateEkmConfig]. + + Attributes: + ekm_config (google.cloud.kms_v1.types.EkmConfig): + Required. [EkmConfig][google.cloud.kms.v1.EkmConfig] with + updated values. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. List of fields to be updated in + this request. + """ + + ekm_config: "EkmConfig" = proto.Field( + proto.MESSAGE, + number=1, + message="EkmConfig", + ) + update_mask: field_mask_pb2.FieldMask = proto.Field( + proto.MESSAGE, + number=2, + message=field_mask_pb2.FieldMask, + ) + + class Certificate(proto.Message): r"""A [Certificate][google.cloud.kms.v1.Certificate] represents an X.509 certificate used to authenticate HTTPS connections to EKM replicas. @@ -311,8 +355,68 @@ class EkmConnection(proto.Message): etag (str): Optional. Etag of the currently stored [EkmConnection][google.cloud.kms.v1.EkmConnection]. + key_management_mode (google.cloud.kms_v1.types.EkmConnection.KeyManagementMode): + Optional. Describes who can perform control plane operations + on the EKM. If unset, this defaults to + [MANUAL][google.cloud.kms.v1.EkmConnection.KeyManagementMode.MANUAL]. + crypto_space_path (str): + Optional. Identifies the EKM Crypto Space that this + [EkmConnection][google.cloud.kms.v1.EkmConnection] maps to. + Note: This field is required if + [KeyManagementMode][google.cloud.kms.v1.EkmConnection.KeyManagementMode] + is + [CLOUD_KMS][google.cloud.kms.v1.EkmConnection.KeyManagementMode.CLOUD_KMS]. """ + class KeyManagementMode(proto.Enum): + r"""[KeyManagementMode][google.cloud.kms.v1.EkmConnection.KeyManagementMode] + describes who can perform control plane cryptographic operations + using this [EkmConnection][google.cloud.kms.v1.EkmConnection]. + + Values: + KEY_MANAGEMENT_MODE_UNSPECIFIED (0): + Not specified. + MANUAL (1): + EKM-side key management operations on + [CryptoKeys][google.cloud.kms.v1.CryptoKey] created with + this [EkmConnection][google.cloud.kms.v1.EkmConnection] must + be initiated from the EKM directly and cannot be performed + from Cloud KMS. This means that: + + - When creating a + [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] + associated with this + [EkmConnection][google.cloud.kms.v1.EkmConnection], the + caller must supply the key path of pre-existing external + key material that will be linked to the + [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion]. + - Destruction of external key material cannot be requested + via the Cloud KMS API and must be performed directly in + the EKM. + - Automatic rotation of key material is not supported. + CLOUD_KMS (2): + All [CryptoKeys][google.cloud.kms.v1.CryptoKey] created with + this [EkmConnection][google.cloud.kms.v1.EkmConnection] use + EKM-side key management operations initiated from Cloud KMS. + This means that: + + - When a + [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] + associated with this + [EkmConnection][google.cloud.kms.v1.EkmConnection] is + created, the EKM automatically generates new key material + and a new key path. The caller cannot supply the key path + of pre-existing external key material. + - Destruction of external key material associated with this + [EkmConnection][google.cloud.kms.v1.EkmConnection] can be + requested by calling + [DestroyCryptoKeyVersion][EkmService.DestroyCryptoKeyVersion]. + - Automatic rotation of key material is supported. + """ + KEY_MANAGEMENT_MODE_UNSPECIFIED = 0 + MANUAL = 1 + CLOUD_KMS = 2 + class ServiceResolver(proto.Message): r"""A [ServiceResolver][google.cloud.kms.v1.EkmConnection.ServiceResolver] @@ -378,6 +482,45 @@ class ServiceResolver(proto.Message): proto.STRING, number=5, ) + key_management_mode: KeyManagementMode = proto.Field( + proto.ENUM, + number=6, + enum=KeyManagementMode, + ) + crypto_space_path: str = proto.Field( + proto.STRING, + number=7, + ) + + +class EkmConfig(proto.Message): + r"""An [EkmConfig][google.cloud.kms.v1.EkmConfig] is a singleton + resource that represents configuration parameters that apply to all + [CryptoKeys][google.cloud.kms.v1.CryptoKey] and + [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion] with a + [ProtectionLevel][google.cloud.kms.v1.ProtectionLevel] of + [EXTERNAL_VPC][CryptoKeyVersion.ProtectionLevel.EXTERNAL_VPC] in a + given project and location. + + Attributes: + name (str): + Output only. The resource name for the + [EkmConfig][google.cloud.kms.v1.EkmConfig] in the format + ``projects/*/locations/*/ekmConfig``. + default_ekm_connection (str): + Optional. Resource name of the default + [EkmConnection][google.cloud.kms.v1.EkmConnection]. Setting + this field to the empty string removes the default. + """ + + name: str = proto.Field( + proto.STRING, + number=1, + ) + default_ekm_connection: str = proto.Field( + proto.STRING, + number=2, + ) __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/google/cloud/kms_v1/types/resources.py b/google/cloud/kms_v1/types/resources.py index d4758a8f..3ab7e2b7 100644 --- a/google/cloud/kms_v1/types/resources.py +++ b/google/cloud/kms_v1/types/resources.py @@ -507,6 +507,16 @@ class CryptoKeyVersion(proto.Message): failure. Only present if [state][google.cloud.kms.v1.CryptoKeyVersion.state] is [IMPORT_FAILED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.IMPORT_FAILED]. + generation_failure_reason (str): + Output only. The root cause of the most recent generation + failure. Only present if + [state][google.cloud.kms.v1.CryptoKeyVersion.state] is + [GENERATION_FAILED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.GENERATION_FAILED]. + external_destruction_failure_reason (str): + Output only. The root cause of the most recent external + destruction failure. Only present if + [state][google.cloud.kms.v1.CryptoKeyVersion.state] is + [EXTERNAL_DESTRUCTION_FAILED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.EXTERNAL_DESTRUCTION_FAILED]. external_protection_level_options (google.cloud.kms_v1.types.ExternalProtectionLevelOptions): ExternalProtectionLevelOptions stores a group of additional fields for configuring a @@ -718,6 +728,22 @@ class CryptoKeyVersionState(proto.Enum): material has been discarded. Additional details can be found in [CryptoKeyVersion.import_failure_reason][google.cloud.kms.v1.CryptoKeyVersion.import_failure_reason]. + GENERATION_FAILED (8): + This version was not generated successfully. It may not be + used, enabled, disabled, or destroyed. Additional details + can be found in + [CryptoKeyVersion.generation_failure_reason][google.cloud.kms.v1.CryptoKeyVersion.generation_failure_reason]. + PENDING_EXTERNAL_DESTRUCTION (9): + This version was destroyed, and it may not be + used or enabled again. Cloud KMS is waiting for + the corresponding key material residing in an + external key manager to be destroyed. + EXTERNAL_DESTRUCTION_FAILED (10): + This version was destroyed, and it may not be used or + enabled again. However, Cloud KMS could not confirm that the + corresponding key material residing in an external key + manager was destroyed. Additional details can be found in + [CryptoKeyVersion.external_destruction_failure_reason][google.cloud.kms.v1.CryptoKeyVersion.external_destruction_failure_reason]. """ CRYPTO_KEY_VERSION_STATE_UNSPECIFIED = 0 PENDING_GENERATION = 5 @@ -727,6 +753,9 @@ class CryptoKeyVersionState(proto.Enum): DESTROY_SCHEDULED = 4 PENDING_IMPORT = 6 IMPORT_FAILED = 7 + GENERATION_FAILED = 8 + PENDING_EXTERNAL_DESTRUCTION = 9 + EXTERNAL_DESTRUCTION_FAILED = 10 class CryptoKeyVersionView(proto.Enum): r"""A view for @@ -810,6 +839,14 @@ class CryptoKeyVersionView(proto.Enum): proto.STRING, number=16, ) + generation_failure_reason: str = proto.Field( + proto.STRING, + number=19, + ) + external_destruction_failure_reason: str = proto.Field( + proto.STRING, + number=20, + ) external_protection_level_options: "ExternalProtectionLevelOptions" = proto.Field( proto.MESSAGE, number=17, diff --git a/samples/generated_samples/cloudkms_v1_generated_ekm_service_get_ekm_config_async.py b/samples/generated_samples/cloudkms_v1_generated_ekm_service_get_ekm_config_async.py new file mode 100644 index 00000000..50ce6b41 --- /dev/null +++ b/samples/generated_samples/cloudkms_v1_generated_ekm_service_get_ekm_config_async.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetEkmConfig +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-kms + + +# [START cloudkms_v1_generated_EkmService_GetEkmConfig_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import kms_v1 + + +async def sample_get_ekm_config(): + # Create a client + client = kms_v1.EkmServiceAsyncClient() + + # Initialize request argument(s) + request = kms_v1.GetEkmConfigRequest( + name="name_value", + ) + + # Make the request + response = await client.get_ekm_config(request=request) + + # Handle the response + print(response) + +# [END cloudkms_v1_generated_EkmService_GetEkmConfig_async] diff --git a/samples/generated_samples/cloudkms_v1_generated_ekm_service_get_ekm_config_sync.py b/samples/generated_samples/cloudkms_v1_generated_ekm_service_get_ekm_config_sync.py new file mode 100644 index 00000000..e90ecab8 --- /dev/null +++ b/samples/generated_samples/cloudkms_v1_generated_ekm_service_get_ekm_config_sync.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetEkmConfig +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-kms + + +# [START cloudkms_v1_generated_EkmService_GetEkmConfig_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import kms_v1 + + +def sample_get_ekm_config(): + # Create a client + client = kms_v1.EkmServiceClient() + + # Initialize request argument(s) + request = kms_v1.GetEkmConfigRequest( + name="name_value", + ) + + # Make the request + response = client.get_ekm_config(request=request) + + # Handle the response + print(response) + +# [END cloudkms_v1_generated_EkmService_GetEkmConfig_sync] diff --git a/samples/generated_samples/cloudkms_v1_generated_ekm_service_update_ekm_config_async.py b/samples/generated_samples/cloudkms_v1_generated_ekm_service_update_ekm_config_async.py new file mode 100644 index 00000000..2284e517 --- /dev/null +++ b/samples/generated_samples/cloudkms_v1_generated_ekm_service_update_ekm_config_async.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateEkmConfig +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-kms + + +# [START cloudkms_v1_generated_EkmService_UpdateEkmConfig_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import kms_v1 + + +async def sample_update_ekm_config(): + # Create a client + client = kms_v1.EkmServiceAsyncClient() + + # Initialize request argument(s) + request = kms_v1.UpdateEkmConfigRequest( + ) + + # Make the request + response = await client.update_ekm_config(request=request) + + # Handle the response + print(response) + +# [END cloudkms_v1_generated_EkmService_UpdateEkmConfig_async] diff --git a/samples/generated_samples/cloudkms_v1_generated_ekm_service_update_ekm_config_sync.py b/samples/generated_samples/cloudkms_v1_generated_ekm_service_update_ekm_config_sync.py new file mode 100644 index 00000000..2a54c051 --- /dev/null +++ b/samples/generated_samples/cloudkms_v1_generated_ekm_service_update_ekm_config_sync.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateEkmConfig +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-kms + + +# [START cloudkms_v1_generated_EkmService_UpdateEkmConfig_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import kms_v1 + + +def sample_update_ekm_config(): + # Create a client + client = kms_v1.EkmServiceClient() + + # Initialize request argument(s) + request = kms_v1.UpdateEkmConfigRequest( + ) + + # Make the request + response = client.update_ekm_config(request=request) + + # Handle the response + print(response) + +# [END cloudkms_v1_generated_EkmService_UpdateEkmConfig_sync] diff --git a/samples/generated_samples/snippet_metadata_google.cloud.kms.v1.json b/samples/generated_samples/snippet_metadata_google.cloud.kms.v1.json index 329608b3..74fd95f8 100644 --- a/samples/generated_samples/snippet_metadata_google.cloud.kms.v1.json +++ b/samples/generated_samples/snippet_metadata_google.cloud.kms.v1.json @@ -188,6 +188,167 @@ ], "title": "cloudkms_v1_generated_ekm_service_create_ekm_connection_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.kms_v1.EkmServiceAsyncClient", + "shortName": "EkmServiceAsyncClient" + }, + "fullName": "google.cloud.kms_v1.EkmServiceAsyncClient.get_ekm_config", + "method": { + "fullName": "google.cloud.kms.v1.EkmService.GetEkmConfig", + "service": { + "fullName": "google.cloud.kms.v1.EkmService", + "shortName": "EkmService" + }, + "shortName": "GetEkmConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.kms_v1.types.GetEkmConfigRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.kms_v1.types.EkmConfig", + "shortName": "get_ekm_config" + }, + "description": "Sample for GetEkmConfig", + "file": "cloudkms_v1_generated_ekm_service_get_ekm_config_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudkms_v1_generated_EkmService_GetEkmConfig_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudkms_v1_generated_ekm_service_get_ekm_config_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.kms_v1.EkmServiceClient", + "shortName": "EkmServiceClient" + }, + "fullName": "google.cloud.kms_v1.EkmServiceClient.get_ekm_config", + "method": { + "fullName": "google.cloud.kms.v1.EkmService.GetEkmConfig", + "service": { + "fullName": "google.cloud.kms.v1.EkmService", + "shortName": "EkmService" + }, + "shortName": "GetEkmConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.kms_v1.types.GetEkmConfigRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.kms_v1.types.EkmConfig", + "shortName": "get_ekm_config" + }, + "description": "Sample for GetEkmConfig", + "file": "cloudkms_v1_generated_ekm_service_get_ekm_config_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudkms_v1_generated_EkmService_GetEkmConfig_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudkms_v1_generated_ekm_service_get_ekm_config_sync.py" + }, { "canonical": true, "clientMethod": { @@ -510,6 +671,175 @@ ], "title": "cloudkms_v1_generated_ekm_service_list_ekm_connections_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.kms_v1.EkmServiceAsyncClient", + "shortName": "EkmServiceAsyncClient" + }, + "fullName": "google.cloud.kms_v1.EkmServiceAsyncClient.update_ekm_config", + "method": { + "fullName": "google.cloud.kms.v1.EkmService.UpdateEkmConfig", + "service": { + "fullName": "google.cloud.kms.v1.EkmService", + "shortName": "EkmService" + }, + "shortName": "UpdateEkmConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.kms_v1.types.UpdateEkmConfigRequest" + }, + { + "name": "ekm_config", + "type": "google.cloud.kms_v1.types.EkmConfig" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.kms_v1.types.EkmConfig", + "shortName": "update_ekm_config" + }, + "description": "Sample for UpdateEkmConfig", + "file": "cloudkms_v1_generated_ekm_service_update_ekm_config_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudkms_v1_generated_EkmService_UpdateEkmConfig_async", + "segments": [ + { + "end": 50, + "start": 27, + "type": "FULL" + }, + { + "end": 50, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 47, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 51, + "start": 48, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudkms_v1_generated_ekm_service_update_ekm_config_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.kms_v1.EkmServiceClient", + "shortName": "EkmServiceClient" + }, + "fullName": "google.cloud.kms_v1.EkmServiceClient.update_ekm_config", + "method": { + "fullName": "google.cloud.kms.v1.EkmService.UpdateEkmConfig", + "service": { + "fullName": "google.cloud.kms.v1.EkmService", + "shortName": "EkmService" + }, + "shortName": "UpdateEkmConfig" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.kms_v1.types.UpdateEkmConfigRequest" + }, + { + "name": "ekm_config", + "type": "google.cloud.kms_v1.types.EkmConfig" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.kms_v1.types.EkmConfig", + "shortName": "update_ekm_config" + }, + "description": "Sample for UpdateEkmConfig", + "file": "cloudkms_v1_generated_ekm_service_update_ekm_config_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "cloudkms_v1_generated_EkmService_UpdateEkmConfig_sync", + "segments": [ + { + "end": 50, + "start": 27, + "type": "FULL" + }, + { + "end": 50, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 44, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 47, + "start": 45, + "type": "REQUEST_EXECUTION" + }, + { + "end": 51, + "start": 48, + "type": "RESPONSE_HANDLING" + } + ], + "title": "cloudkms_v1_generated_ekm_service_update_ekm_config_sync.py" + }, { "canonical": true, "clientMethod": { diff --git a/scripts/fixup_kms_v1_keywords.py b/scripts/fixup_kms_v1_keywords.py index ce151fed..fa31e4f6 100644 --- a/scripts/fixup_kms_v1_keywords.py +++ b/scripts/fixup_kms_v1_keywords.py @@ -52,6 +52,7 @@ class kmsCallTransformer(cst.CSTTransformer): 'generate_random_bytes': ('location', 'length_bytes', 'protection_level', ), 'get_crypto_key': ('name', ), 'get_crypto_key_version': ('name', ), + 'get_ekm_config': ('name', ), 'get_ekm_connection': ('name', ), 'get_import_job': ('name', ), 'get_key_ring': ('name', ), @@ -68,6 +69,7 @@ class kmsCallTransformer(cst.CSTTransformer): 'update_crypto_key': ('crypto_key', 'update_mask', ), 'update_crypto_key_primary_version': ('name', 'crypto_key_version_id', ), 'update_crypto_key_version': ('crypto_key_version', 'update_mask', ), + 'update_ekm_config': ('ekm_config', 'update_mask', ), 'update_ekm_connection': ('ekm_connection', 'update_mask', ), 'get_iam_policy': ('resource', 'options', ), 'set_iam_policy': ('resource', 'policy', ), diff --git a/tests/unit/gapic/kms_v1/test_ekm_service.py b/tests/unit/gapic/kms_v1/test_ekm_service.py index 8b33a634..a61974d8 100644 --- a/tests/unit/gapic/kms_v1/test_ekm_service.py +++ b/tests/unit/gapic/kms_v1/test_ekm_service.py @@ -1159,6 +1159,8 @@ def test_get_ekm_connection(request_type, transport: str = "grpc"): call.return_value = ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) response = client.get_ekm_connection(request) @@ -1171,6 +1173,11 @@ def test_get_ekm_connection(request_type, transport: str = "grpc"): assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" def test_get_ekm_connection_empty_call(): @@ -1213,6 +1220,8 @@ async def test_get_ekm_connection_async( ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) ) response = await client.get_ekm_connection(request) @@ -1226,6 +1235,11 @@ async def test_get_ekm_connection_async( assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" @pytest.mark.asyncio @@ -1409,6 +1423,8 @@ def test_create_ekm_connection(request_type, transport: str = "grpc"): call.return_value = ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) response = client.create_ekm_connection(request) @@ -1421,6 +1437,11 @@ def test_create_ekm_connection(request_type, transport: str = "grpc"): assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" def test_create_ekm_connection_empty_call(): @@ -1463,6 +1484,8 @@ async def test_create_ekm_connection_async( ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) ) response = await client.create_ekm_connection(request) @@ -1476,6 +1499,11 @@ async def test_create_ekm_connection_async( assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" @pytest.mark.asyncio @@ -1679,6 +1707,8 @@ def test_update_ekm_connection(request_type, transport: str = "grpc"): call.return_value = ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) response = client.update_ekm_connection(request) @@ -1691,6 +1721,11 @@ def test_update_ekm_connection(request_type, transport: str = "grpc"): assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" def test_update_ekm_connection_empty_call(): @@ -1733,6 +1768,8 @@ async def test_update_ekm_connection_async( ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) ) response = await client.update_ekm_connection(request) @@ -1746,6 +1783,11 @@ async def test_update_ekm_connection_async( assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" @pytest.mark.asyncio @@ -1917,364 +1959,1539 @@ async def test_update_ekm_connection_flattened_error_async(): @pytest.mark.parametrize( "request_type", [ - ekm_service.ListEkmConnectionsRequest, + ekm_service.GetEkmConfigRequest, dict, ], ) -def test_list_ekm_connections_rest(request_type): +def test_get_ekm_config(request_type, transport: str = "grpc"): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport="rest", + transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} - request = request_type(**request_init) + # 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 http request call within the method and fake a response. - with mock.patch.object(type(client.transport._session), "request") as req: - # Designate an appropriate value for the returned response. - return_value = ekm_service.ListEkmConnectionsResponse( - next_page_token="next_page_token_value", - total_size=1086, + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = ekm_service.EkmConfig( + name="name_value", + default_ekm_connection="default_ekm_connection_value", ) + response = client.get_ekm_config(request) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - pb_return_value = ekm_service.ListEkmConnectionsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value - response = client.list_ekm_connections(request) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == ekm_service.GetEkmConfigRequest() # Establish that the response is the type that we expect. - assert isinstance(response, pagers.ListEkmConnectionsPager) - assert response.next_page_token == "next_page_token_value" - assert response.total_size == 1086 - + assert isinstance(response, ekm_service.EkmConfig) + assert response.name == "name_value" + assert response.default_ekm_connection == "default_ekm_connection_value" -def test_list_ekm_connections_rest_required_fields( - request_type=ekm_service.ListEkmConnectionsRequest, -): - transport_class = transports.EkmServiceRestTransport - request_init = {} - request_init["parent"] = "" - request = request_type(**request_init) - pb_request = request_type.pb(request) - jsonified_request = json.loads( - json_format.MessageToJson( - pb_request, - including_default_value_fields=False, - use_integers_for_enums=False, - ) +def test_get_ekm_config_empty_call(): + # This test is a coverage failsafe to make sure that totally empty calls, + # i.e. request == None and no flattened fields passed, work. + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) - # verify fields with default values are dropped + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + client.get_ekm_config() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == ekm_service.GetEkmConfigRequest() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_ekm_connections._get_unset_required_fields(jsonified_request) - jsonified_request.update(unset_fields) - # verify required fields with default values are now present +@pytest.mark.asyncio +async def test_get_ekm_config_async( + transport: str = "grpc_asyncio", request_type=ekm_service.GetEkmConfigRequest +): + client = EkmServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - jsonified_request["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() - unset_fields = transport_class( - credentials=ga_credentials.AnonymousCredentials() - ).list_ekm_connections._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "filter", - "order_by", - "page_size", - "page_token", + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + ekm_service.EkmConfig( + name="name_value", + default_ekm_connection="default_ekm_connection_value", + ) ) - ) - jsonified_request.update(unset_fields) + response = await client.get_ekm_config(request) - # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == ekm_service.GetEkmConfigRequest() - client = EkmServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - request = request_type(**request_init) + # Establish that the response is the type that we expect. + assert isinstance(response, ekm_service.EkmConfig) + assert response.name == "name_value" + assert response.default_ekm_connection == "default_ekm_connection_value" - # Designate an appropriate value for the returned response. - return_value = ekm_service.ListEkmConnectionsResponse() - # Mock the http request call 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 +@pytest.mark.asyncio +async def test_get_ekm_config_async_from_dict(): + await test_get_ekm_config_async(request_type=dict) - pb_return_value = ekm_service.ListEkmConnectionsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value +def test_get_ekm_config_field_headers(): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) - response = client.list_ekm_connections(request) + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = ekm_service.GetEkmConfigRequest() - expected_params = [("$alt", "json;enum-encoding=int")] - actual_params = req.call_args.kwargs["params"] - assert expected_params == actual_params + request.name = "name_value" + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + call.return_value = ekm_service.EkmConfig() + client.get_ekm_config(request) -def test_list_ekm_connections_rest_unset_required_fields(): - transport = transports.EkmServiceRestTransport( - credentials=ga_credentials.AnonymousCredentials - ) + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request - unset_fields = transport.list_ekm_connections._get_unset_required_fields({}) - assert set(unset_fields) == ( - set( - ( - "filter", - "orderBy", - "pageSize", - "pageToken", - ) - ) - & set(("parent",)) - ) + # 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.parametrize("null_interceptor", [True, False]) -def test_list_ekm_connections_rest_interceptors(null_interceptor): - transport = transports.EkmServiceRestTransport( +@pytest.mark.asyncio +async def test_get_ekm_config_field_headers_async(): + client = EkmServiceAsyncClient( credentials=ga_credentials.AnonymousCredentials(), - interceptor=None - if null_interceptor - else transports.EkmServiceRestInterceptor(), ) - client = EkmServiceClient(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.EkmServiceRestInterceptor, "post_list_ekm_connections" - ) as post, mock.patch.object( - transports.EkmServiceRestInterceptor, "pre_list_ekm_connections" - ) as pre: - pre.assert_not_called() - post.assert_not_called() - pb_message = ekm_service.ListEkmConnectionsRequest.pb( - ekm_service.ListEkmConnectionsRequest() - ) - transcode.return_value = { - "method": "post", - "uri": "my_uri", - "body": pb_message, - "query_params": pb_message, - } - req.return_value = Response() - req.return_value.status_code = 200 - req.return_value.request = PreparedRequest() - req.return_value._content = ekm_service.ListEkmConnectionsResponse.to_json( - ekm_service.ListEkmConnectionsResponse() - ) + # 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 = ekm_service.GetEkmConfigRequest() - request = ekm_service.ListEkmConnectionsRequest() - metadata = [ - ("key", "val"), - ("cephalopod", "squid"), - ] - pre.return_value = request, metadata - post.return_value = ekm_service.ListEkmConnectionsResponse() + request.name = "name_value" - client.list_ekm_connections( - request, - metadata=[ - ("key", "val"), - ("cephalopod", "squid"), - ], + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + ekm_service.EkmConfig() ) + await client.get_ekm_config(request) - pre.assert_called_once() - post.assert_called_once() + # 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_list_ekm_connections_rest_bad_request( - transport: str = "rest", request_type=ekm_service.ListEkmConnectionsRequest -): +def test_get_ekm_config_flattened(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), - transport=transport, ) - # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} - request = request_type(**request_init) + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = ekm_service.EkmConfig() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_ekm_config( + name="name_value", + ) - # Mock the http request call within the method and fake a BadRequest error. - with mock.patch.object(Session, "request") as req, pytest.raises( - core_exceptions.BadRequest - ): - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 400 - response_value.request = Request() - req.return_value = response_value - client.list_ekm_connections(request) + # 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_list_ekm_connections_rest_flattened(): +def test_get_ekm_config_flattened_error(): client = EkmServiceClient( 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 = ekm_service.ListEkmConnectionsResponse() + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_ekm_config( + ekm_service.GetEkmConfigRequest(), + name="name_value", + ) - # 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) +@pytest.mark.asyncio +async def test_get_ekm_config_flattened_async(): + client = EkmServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) - # Wrap the value into a proper Response obj - response_value = Response() - response_value.status_code = 200 - pb_return_value = ekm_service.ListEkmConnectionsResponse.pb(return_value) - json_return_value = json_format.MessageToJson(pb_return_value) - response_value._content = json_return_value.encode("UTF-8") - req.return_value = response_value + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_ekm_config), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = ekm_service.EkmConfig() - client.list_ekm_connections(**mock_args) + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + ekm_service.EkmConfig() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_ekm_config( + name="name_value", + ) # Establish that the underlying call was made with the expected # request object values. - assert len(req.mock_calls) == 1 - _, args, _ = req.mock_calls[0] - assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}/ekmConnections" - % 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_get_ekm_config_flattened_error_async(): + client = EkmServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.get_ekm_config( + ekm_service.GetEkmConfigRequest(), + name="name_value", ) -def test_list_ekm_connections_rest_flattened_error(transport: str = "rest"): +@pytest.mark.parametrize( + "request_type", + [ + ekm_service.UpdateEkmConfigRequest, + dict, + ], +) +def test_update_ekm_config(request_type, transport: str = "grpc"): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = ekm_service.EkmConfig( + name="name_value", + default_ekm_connection="default_ekm_connection_value", + ) + response = client.update_ekm_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == ekm_service.UpdateEkmConfigRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, ekm_service.EkmConfig) + assert response.name == "name_value" + assert response.default_ekm_connection == "default_ekm_connection_value" + + +def test_update_ekm_config_empty_call(): + # This test is a coverage failsafe to make sure that totally empty calls, + # i.e. request == None and no flattened fields passed, work. client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + client.update_ekm_config() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == ekm_service.UpdateEkmConfigRequest() + + +@pytest.mark.asyncio +async def test_update_ekm_config_async( + transport: str = "grpc_asyncio", request_type=ekm_service.UpdateEkmConfigRequest +): + client = EkmServiceAsyncClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, ) + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + ekm_service.EkmConfig( + name="name_value", + default_ekm_connection="default_ekm_connection_value", + ) + ) + response = await client.update_ekm_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == ekm_service.UpdateEkmConfigRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, ekm_service.EkmConfig) + assert response.name == "name_value" + assert response.default_ekm_connection == "default_ekm_connection_value" + + +@pytest.mark.asyncio +async def test_update_ekm_config_async_from_dict(): + await test_update_ekm_config_async(request_type=dict) + + +def test_update_ekm_config_field_headers(): + client = EkmServiceClient( + 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 = ekm_service.UpdateEkmConfigRequest() + + request.ekm_config.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + call.return_value = ekm_service.EkmConfig() + client.update_ekm_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "ekm_config.name=name_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_update_ekm_config_field_headers_async(): + client = EkmServiceAsyncClient( + 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 = ekm_service.UpdateEkmConfigRequest() + + request.ekm_config.name = "name_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + ekm_service.EkmConfig() + ) + await client.update_ekm_config(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "ekm_config.name=name_value", + ) in kw["metadata"] + + +def test_update_ekm_config_flattened(): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = ekm_service.EkmConfig() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.update_ekm_config( + ekm_config=ekm_service.EkmConfig(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].ekm_config + mock_val = ekm_service.EkmConfig(name="name_value") + assert arg == mock_val + arg = args[0].update_mask + mock_val = field_mask_pb2.FieldMask(paths=["paths_value"]) + assert arg == mock_val + + +def test_update_ekm_config_flattened_error(): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): - client.list_ekm_connections( - ekm_service.ListEkmConnectionsRequest(), - parent="parent_value", + client.update_ekm_config( + ekm_service.UpdateEkmConfigRequest(), + ekm_config=ekm_service.EkmConfig(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_list_ekm_connections_rest_pager(transport: str = "rest"): - client = EkmServiceClient( +@pytest.mark.asyncio +async def test_update_ekm_config_flattened_async(): + client = EkmServiceAsyncClient( 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 = ( - ekm_service.ListEkmConnectionsResponse( - ekm_connections=[ - ekm_service.EkmConnection(), - ekm_service.EkmConnection(), - ekm_service.EkmConnection(), - ], - next_page_token="abc", - ), - ekm_service.ListEkmConnectionsResponse( - ekm_connections=[], - next_page_token="def", - ), - ekm_service.ListEkmConnectionsResponse( - ekm_connections=[ - ekm_service.EkmConnection(), + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_ekm_config), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = ekm_service.EkmConfig() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + ekm_service.EkmConfig() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.update_ekm_config( + ekm_config=ekm_service.EkmConfig(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].ekm_config + mock_val = ekm_service.EkmConfig(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_ekm_config_flattened_error_async(): + client = EkmServiceAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.update_ekm_config( + ekm_service.UpdateEkmConfigRequest(), + ekm_config=ekm_service.EkmConfig(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.parametrize( + "request_type", + [ + ekm_service.ListEkmConnectionsRequest, + dict, + ], +) +def test_list_ekm_connections_rest(request_type): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = ekm_service.ListEkmConnectionsResponse( + next_page_token="next_page_token_value", + total_size=1086, + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = ekm_service.ListEkmConnectionsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_ekm_connections(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListEkmConnectionsPager) + assert response.next_page_token == "next_page_token_value" + assert response.total_size == 1086 + + +def test_list_ekm_connections_rest_required_fields( + request_type=ekm_service.ListEkmConnectionsRequest, +): + transport_class = transports.EkmServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_ekm_connections._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_ekm_connections._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = ekm_service.ListEkmConnectionsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = ekm_service.ListEkmConnectionsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_ekm_connections(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_ekm_connections_rest_unset_required_fields(): + transport = transports.EkmServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_ekm_connections._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_ekm_connections_rest_interceptors(null_interceptor): + transport = transports.EkmServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.EkmServiceRestInterceptor(), + ) + client = EkmServiceClient(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.EkmServiceRestInterceptor, "post_list_ekm_connections" + ) as post, mock.patch.object( + transports.EkmServiceRestInterceptor, "pre_list_ekm_connections" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = ekm_service.ListEkmConnectionsRequest.pb( + ekm_service.ListEkmConnectionsRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = ekm_service.ListEkmConnectionsResponse.to_json( + ekm_service.ListEkmConnectionsResponse() + ) + + request = ekm_service.ListEkmConnectionsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = ekm_service.ListEkmConnectionsResponse() + + client.list_ekm_connections( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_ekm_connections_rest_bad_request( + transport: str = "rest", request_type=ekm_service.ListEkmConnectionsRequest +): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_ekm_connections(request) + + +def test_list_ekm_connections_rest_flattened(): + client = EkmServiceClient( + 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 = ekm_service.ListEkmConnectionsResponse() + + # 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 + pb_return_value = ekm_service.ListEkmConnectionsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_ekm_connections(**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/*}/ekmConnections" + % client.transport._host, + args[1], + ) + + +def test_list_ekm_connections_rest_flattened_error(transport: str = "rest"): + client = EkmServiceClient( + 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_ekm_connections( + ekm_service.ListEkmConnectionsRequest(), + parent="parent_value", + ) + + +def test_list_ekm_connections_rest_pager(transport: str = "rest"): + client = EkmServiceClient( + 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 = ( + ekm_service.ListEkmConnectionsResponse( + ekm_connections=[ + ekm_service.EkmConnection(), + ekm_service.EkmConnection(), + ekm_service.EkmConnection(), + ], + next_page_token="abc", + ), + ekm_service.ListEkmConnectionsResponse( + ekm_connections=[], + next_page_token="def", + ), + ekm_service.ListEkmConnectionsResponse( + ekm_connections=[ + ekm_service.EkmConnection(), + ], + next_page_token="ghi", + ), + ekm_service.ListEkmConnectionsResponse( + ekm_connections=[ + ekm_service.EkmConnection(), + ekm_service.EkmConnection(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + ekm_service.ListEkmConnectionsResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "projects/sample1/locations/sample2"} + + pager = client.list_ekm_connections(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, ekm_service.EkmConnection) for i in results) + + pages = list(client.list_ekm_connections(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + ekm_service.GetEkmConnectionRequest, + dict, + ], +) +def test_get_ekm_connection_rest(request_type): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/ekmConnections/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 = ekm_service.EkmConnection( + name="name_value", + etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = ekm_service.EkmConnection.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_ekm_connection(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, ekm_service.EkmConnection) + assert response.name == "name_value" + assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" + + +def test_get_ekm_connection_rest_required_fields( + request_type=ekm_service.GetEkmConnectionRequest, +): + transport_class = transports.EkmServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_ekm_connection._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_ekm_connection._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 = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = ekm_service.EkmConnection() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = ekm_service.EkmConnection.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_ekm_connection(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_ekm_connection_rest_unset_required_fields(): + transport = transports.EkmServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_ekm_connection._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_ekm_connection_rest_interceptors(null_interceptor): + transport = transports.EkmServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.EkmServiceRestInterceptor(), + ) + client = EkmServiceClient(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.EkmServiceRestInterceptor, "post_get_ekm_connection" + ) as post, mock.patch.object( + transports.EkmServiceRestInterceptor, "pre_get_ekm_connection" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = ekm_service.GetEkmConnectionRequest.pb( + ekm_service.GetEkmConnectionRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = ekm_service.EkmConnection.to_json( + ekm_service.EkmConnection() + ) + + request = ekm_service.GetEkmConnectionRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = ekm_service.EkmConnection() + + client.get_ekm_connection( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_ekm_connection_rest_bad_request( + transport: str = "rest", request_type=ekm_service.GetEkmConnectionRequest +): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/ekmConnections/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_ekm_connection(request) + + +def test_get_ekm_connection_rest_flattened(): + client = EkmServiceClient( + 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 = ekm_service.EkmConnection() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/ekmConnections/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 + pb_return_value = ekm_service.EkmConnection.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_ekm_connection(**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/*/ekmConnections/*}" + % client.transport._host, + args[1], + ) + + +def test_get_ekm_connection_rest_flattened_error(transport: str = "rest"): + client = EkmServiceClient( + 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_ekm_connection( + ekm_service.GetEkmConnectionRequest(), + name="name_value", + ) + + +def test_get_ekm_connection_rest_error(): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + ekm_service.CreateEkmConnectionRequest, + dict, + ], +) +def test_create_ekm_connection_rest(request_type): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["ekm_connection"] = { + "name": "name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "service_resolvers": [ + { + "service_directory_service": "service_directory_service_value", + "endpoint_filter": "endpoint_filter_value", + "hostname": "hostname_value", + "server_certificates": [ + { + "raw_der": b"raw_der_blob", + "parsed": True, + "issuer": "issuer_value", + "subject": "subject_value", + "subject_alternative_dns_names": [ + "subject_alternative_dns_names_value1", + "subject_alternative_dns_names_value2", + ], + "not_before_time": {}, + "not_after_time": {}, + "serial_number": "serial_number_value", + "sha256_fingerprint": "sha256_fingerprint_value", + } ], - next_page_token="ghi", - ), - ekm_service.ListEkmConnectionsResponse( - ekm_connections=[ - ekm_service.EkmConnection(), - ekm_service.EkmConnection(), + } + ], + "etag": "etag_value", + "key_management_mode": 1, + "crypto_space_path": "crypto_space_path_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = ekm_service.EkmConnection( + name="name_value", + etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = ekm_service.EkmConnection.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.create_ekm_connection(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, ekm_service.EkmConnection) + assert response.name == "name_value" + assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" + + +def test_create_ekm_connection_rest_required_fields( + request_type=ekm_service.CreateEkmConnectionRequest, +): + transport_class = transports.EkmServiceRestTransport + + request_init = {} + request_init["parent"] = "" + request_init["ekm_connection_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + assert "ekmConnectionId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_ekm_connection._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "ekmConnectionId" in jsonified_request + assert jsonified_request["ekmConnectionId"] == request_init["ekm_connection_id"] + + jsonified_request["parent"] = "parent_value" + jsonified_request["ekmConnectionId"] = "ekm_connection_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_ekm_connection._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("ekm_connection_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 "ekmConnectionId" in jsonified_request + assert jsonified_request["ekmConnectionId"] == "ekm_connection_id_value" + + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = ekm_service.EkmConnection() + # Mock the http request call 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 + + pb_return_value = ekm_service.EkmConnection.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.create_ekm_connection(request) + + expected_params = [ + ( + "ekmConnectionId", + "", + ), + ("$alt", "json;enum-encoding=int"), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_ekm_connection_rest_unset_required_fields(): + transport = transports.EkmServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_ekm_connection._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("ekmConnectionId",)) + & set( + ( + "parent", + "ekmConnectionId", + "ekmConnection", + ) + ) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_ekm_connection_rest_interceptors(null_interceptor): + transport = transports.EkmServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.EkmServiceRestInterceptor(), + ) + client = EkmServiceClient(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.EkmServiceRestInterceptor, "post_create_ekm_connection" + ) as post, mock.patch.object( + transports.EkmServiceRestInterceptor, "pre_create_ekm_connection" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = ekm_service.CreateEkmConnectionRequest.pb( + ekm_service.CreateEkmConnectionRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = ekm_service.EkmConnection.to_json( + ekm_service.EkmConnection() + ) + + request = ekm_service.CreateEkmConnectionRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = ekm_service.EkmConnection() + + client.create_ekm_connection( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_create_ekm_connection_rest_bad_request( + transport: str = "rest", request_type=ekm_service.CreateEkmConnectionRequest +): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["ekm_connection"] = { + "name": "name_value", + "create_time": {"seconds": 751, "nanos": 543}, + "service_resolvers": [ + { + "service_directory_service": "service_directory_service_value", + "endpoint_filter": "endpoint_filter_value", + "hostname": "hostname_value", + "server_certificates": [ + { + "raw_der": b"raw_der_blob", + "parsed": True, + "issuer": "issuer_value", + "subject": "subject_value", + "subject_alternative_dns_names": [ + "subject_alternative_dns_names_value1", + "subject_alternative_dns_names_value2", + ], + "not_before_time": {}, + "not_after_time": {}, + "serial_number": "serial_number_value", + "sha256_fingerprint": "sha256_fingerprint_value", + } ], - ), + } + ], + "etag": "etag_value", + "key_management_mode": 1, + "crypto_space_path": "crypto_space_path_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.create_ekm_connection(request) + + +def test_create_ekm_connection_rest_flattened(): + client = EkmServiceClient( + 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 = ekm_service.EkmConnection() + + # 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", + ekm_connection_id="ekm_connection_id_value", + ekm_connection=ekm_service.EkmConnection(name="name_value"), ) - # Two responses for two calls - response = response + response + mock_args.update(sample_request) - # Wrap the values into proper Response objs - response = tuple( - ekm_service.ListEkmConnectionsResponse.to_json(x) for x in response + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = ekm_service.EkmConnection.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_ekm_connection(**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/*}/ekmConnections" + % client.transport._host, + args[1], ) - return_values = tuple(Response() for i in response) - for return_val, response_val in zip(return_values, response): - return_val._content = response_val.encode("UTF-8") - return_val.status_code = 200 - req.side_effect = return_values - sample_request = {"parent": "projects/sample1/locations/sample2"} - pager = client.list_ekm_connections(request=sample_request) +def test_create_ekm_connection_rest_flattened_error(transport: str = "rest"): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) - results = list(pager) - assert len(results) == 6 - assert all(isinstance(i, ekm_service.EkmConnection) for i in results) + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_ekm_connection( + ekm_service.CreateEkmConnectionRequest(), + parent="parent_value", + ekm_connection_id="ekm_connection_id_value", + ekm_connection=ekm_service.EkmConnection(name="name_value"), + ) - pages = list(client.list_ekm_connections(request=sample_request).pages) - for page_, token in zip(pages, ["abc", "def", "ghi", ""]): - assert page_.raw_page.next_page_token == token + +def test_create_ekm_connection_rest_error(): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) @pytest.mark.parametrize( "request_type", [ - ekm_service.GetEkmConnectionRequest, + ekm_service.UpdateEkmConnectionRequest, dict, ], ) -def test_get_ekm_connection_rest(request_type): +def test_update_ekm_connection_rest(request_type): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/ekmConnections/sample3"} + request_init = { + "ekm_connection": { + "name": "projects/sample1/locations/sample2/ekmConnections/sample3" + } + } + request_init["ekm_connection"] = { + "name": "projects/sample1/locations/sample2/ekmConnections/sample3", + "create_time": {"seconds": 751, "nanos": 543}, + "service_resolvers": [ + { + "service_directory_service": "service_directory_service_value", + "endpoint_filter": "endpoint_filter_value", + "hostname": "hostname_value", + "server_certificates": [ + { + "raw_der": b"raw_der_blob", + "parsed": True, + "issuer": "issuer_value", + "subject": "subject_value", + "subject_alternative_dns_names": [ + "subject_alternative_dns_names_value1", + "subject_alternative_dns_names_value2", + ], + "not_before_time": {}, + "not_after_time": {}, + "serial_number": "serial_number_value", + "sha256_fingerprint": "sha256_fingerprint_value", + } + ], + } + ], + "etag": "etag_value", + "key_management_mode": 1, + "crypto_space_path": "crypto_space_path_value", + } request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -2283,6 +3500,8 @@ def test_get_ekm_connection_rest(request_type): return_value = ekm_service.EkmConnection( name="name_value", etag="etag_value", + key_management_mode=ekm_service.EkmConnection.KeyManagementMode.MANUAL, + crypto_space_path="crypto_space_path_value", ) # Wrap the value into a proper Response obj @@ -2293,21 +3512,25 @@ def test_get_ekm_connection_rest(request_type): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_ekm_connection(request) + response = client.update_ekm_connection(request) # Establish that the response is the type that we expect. assert isinstance(response, ekm_service.EkmConnection) assert response.name == "name_value" assert response.etag == "etag_value" + assert ( + response.key_management_mode + == ekm_service.EkmConnection.KeyManagementMode.MANUAL + ) + assert response.crypto_space_path == "crypto_space_path_value" -def test_get_ekm_connection_rest_required_fields( - request_type=ekm_service.GetEkmConnectionRequest, +def test_update_ekm_connection_rest_required_fields( + request_type=ekm_service.UpdateEkmConnectionRequest, ): transport_class = transports.EkmServiceRestTransport request_init = {} - request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -2322,21 +3545,19 @@ def test_get_ekm_connection_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).get_ekm_connection._get_unset_required_fields(jsonified_request) + ).update_ekm_connection._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_ekm_connection._get_unset_required_fields(jsonified_request) + ).update_ekm_connection._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "name" in jsonified_request - assert jsonified_request["name"] == "name_value" client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2357,9 +3578,10 @@ def test_get_ekm_connection_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "get", + "method": "patch", "query_params": pb_request, } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() @@ -2371,24 +3593,32 @@ def test_get_ekm_connection_rest_required_fields( response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.get_ekm_connection(request) + response = client.update_ekm_connection(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_get_ekm_connection_rest_unset_required_fields(): +def test_update_ekm_connection_rest_unset_required_fields(): transport = transports.EkmServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.get_ekm_connection._get_unset_required_fields({}) - assert set(unset_fields) == (set(()) & set(("name",))) + unset_fields = transport.update_ekm_connection._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("updateMask",)) + & set( + ( + "ekmConnection", + "updateMask", + ) + ) + ) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_ekm_connection_rest_interceptors(null_interceptor): +def test_update_ekm_connection_rest_interceptors(null_interceptor): transport = transports.EkmServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -2401,14 +3631,14 @@ def test_get_ekm_connection_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.EkmServiceRestInterceptor, "post_get_ekm_connection" + transports.EkmServiceRestInterceptor, "post_update_ekm_connection" ) as post, mock.patch.object( - transports.EkmServiceRestInterceptor, "pre_get_ekm_connection" + transports.EkmServiceRestInterceptor, "pre_update_ekm_connection" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = ekm_service.GetEkmConnectionRequest.pb( - ekm_service.GetEkmConnectionRequest() + pb_message = ekm_service.UpdateEkmConnectionRequest.pb( + ekm_service.UpdateEkmConnectionRequest() ) transcode.return_value = { "method": "post", @@ -2424,7 +3654,7 @@ def test_get_ekm_connection_rest_interceptors(null_interceptor): ekm_service.EkmConnection() ) - request = ekm_service.GetEkmConnectionRequest() + request = ekm_service.UpdateEkmConnectionRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -2432,7 +3662,7 @@ def test_get_ekm_connection_rest_interceptors(null_interceptor): pre.return_value = request, metadata post.return_value = ekm_service.EkmConnection() - client.get_ekm_connection( + client.update_ekm_connection( request, metadata=[ ("key", "val"), @@ -2444,8 +3674,8 @@ def test_get_ekm_connection_rest_interceptors(null_interceptor): post.assert_called_once() -def test_get_ekm_connection_rest_bad_request( - transport: str = "rest", request_type=ekm_service.GetEkmConnectionRequest +def test_update_ekm_connection_rest_bad_request( + transport: str = "rest", request_type=ekm_service.UpdateEkmConnectionRequest ): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2453,7 +3683,41 @@ def test_get_ekm_connection_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"name": "projects/sample1/locations/sample2/ekmConnections/sample3"} + request_init = { + "ekm_connection": { + "name": "projects/sample1/locations/sample2/ekmConnections/sample3" + } + } + request_init["ekm_connection"] = { + "name": "projects/sample1/locations/sample2/ekmConnections/sample3", + "create_time": {"seconds": 751, "nanos": 543}, + "service_resolvers": [ + { + "service_directory_service": "service_directory_service_value", + "endpoint_filter": "endpoint_filter_value", + "hostname": "hostname_value", + "server_certificates": [ + { + "raw_der": b"raw_der_blob", + "parsed": True, + "issuer": "issuer_value", + "subject": "subject_value", + "subject_alternative_dns_names": [ + "subject_alternative_dns_names_value1", + "subject_alternative_dns_names_value2", + ], + "not_before_time": {}, + "not_after_time": {}, + "serial_number": "serial_number_value", + "sha256_fingerprint": "sha256_fingerprint_value", + } + ], + } + ], + "etag": "etag_value", + "key_management_mode": 1, + "crypto_space_path": "crypto_space_path_value", + } request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -2465,10 +3729,10 @@ def test_get_ekm_connection_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.get_ekm_connection(request) + client.update_ekm_connection(request) -def test_get_ekm_connection_rest_flattened(): +def test_update_ekm_connection_rest_flattened(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -2481,12 +3745,15 @@ def test_get_ekm_connection_rest_flattened(): # get arguments that satisfy an http rule for this method sample_request = { - "name": "projects/sample1/locations/sample2/ekmConnections/sample3" + "ekm_connection": { + "name": "projects/sample1/locations/sample2/ekmConnections/sample3" + } } # get truthy value for each flattened field mock_args = dict( - name="name_value", + ekm_connection=ekm_service.EkmConnection(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -2498,20 +3765,20 @@ def test_get_ekm_connection_rest_flattened(): response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.get_ekm_connection(**mock_args) + client.update_ekm_connection(**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/*/ekmConnections/*}" + "%s/v1/{ekm_connection.name=projects/*/locations/*/ekmConnections/*}" % client.transport._host, args[1], ) -def test_get_ekm_connection_rest_flattened_error(transport: str = "rest"): +def test_update_ekm_connection_rest_flattened_error(transport: str = "rest"): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -2520,95 +3787,67 @@ def test_get_ekm_connection_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_ekm_connection( - ekm_service.GetEkmConnectionRequest(), - name="name_value", + client.update_ekm_connection( + ekm_service.UpdateEkmConnectionRequest(), + ekm_connection=ekm_service.EkmConnection(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_get_ekm_connection_rest_error(): +def test_update_ekm_connection_rest_error(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) - - -@pytest.mark.parametrize( - "request_type", - [ - ekm_service.CreateEkmConnectionRequest, - dict, - ], -) -def test_create_ekm_connection_rest(request_type): - client = EkmServiceClient( - credentials=ga_credentials.AnonymousCredentials(), - transport="rest", - ) - - # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} - request_init["ekm_connection"] = { - "name": "name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "service_resolvers": [ - { - "service_directory_service": "service_directory_service_value", - "endpoint_filter": "endpoint_filter_value", - "hostname": "hostname_value", - "server_certificates": [ - { - "raw_der": b"raw_der_blob", - "parsed": True, - "issuer": "issuer_value", - "subject": "subject_value", - "subject_alternative_dns_names": [ - "subject_alternative_dns_names_value1", - "subject_alternative_dns_names_value2", - ], - "not_before_time": {}, - "not_after_time": {}, - "serial_number": "serial_number_value", - "sha256_fingerprint": "sha256_fingerprint_value", - } - ], - } - ], - "etag": "etag_value", - } + + +@pytest.mark.parametrize( + "request_type", + [ + ekm_service.GetEkmConfigRequest, + dict, + ], +) +def test_get_ekm_config_rest(request_type): + client = EkmServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/ekmConfig"} 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 = ekm_service.EkmConnection( + return_value = ekm_service.EkmConfig( name="name_value", - etag="etag_value", + default_ekm_connection="default_ekm_connection_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = ekm_service.EkmConnection.pb(return_value) + pb_return_value = ekm_service.EkmConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_ekm_connection(request) + response = client.get_ekm_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, ekm_service.EkmConnection) + assert isinstance(response, ekm_service.EkmConfig) assert response.name == "name_value" - assert response.etag == "etag_value" + assert response.default_ekm_connection == "default_ekm_connection_value" -def test_create_ekm_connection_rest_required_fields( - request_type=ekm_service.CreateEkmConnectionRequest, +def test_get_ekm_config_rest_required_fields( + request_type=ekm_service.GetEkmConfigRequest, ): transport_class = transports.EkmServiceRestTransport request_init = {} - request_init["parent"] = "" - request_init["ekm_connection_id"] = "" + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -2620,32 +3859,24 @@ def test_create_ekm_connection_rest_required_fields( ) # verify fields with default values are dropped - assert "ekmConnectionId" not in jsonified_request unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_ekm_connection._get_unset_required_fields(jsonified_request) + ).get_ekm_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present - assert "ekmConnectionId" in jsonified_request - assert jsonified_request["ekmConnectionId"] == request_init["ekm_connection_id"] - jsonified_request["parent"] = "parent_value" - jsonified_request["ekmConnectionId"] = "ekm_connection_id_value" + jsonified_request["name"] = "name_value" unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).create_ekm_connection._get_unset_required_fields(jsonified_request) - # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set(("ekm_connection_id",)) + ).get_ekm_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone - assert "parent" in jsonified_request - assert jsonified_request["parent"] == "parent_value" - assert "ekmConnectionId" in jsonified_request - assert jsonified_request["ekmConnectionId"] == "ekm_connection_id_value" + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2654,7 +3885,7 @@ def test_create_ekm_connection_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = ekm_service.EkmConnection() + return_value = ekm_service.EkmConfig() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -2666,54 +3897,38 @@ def test_create_ekm_connection_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "post", + "method": "get", "query_params": pb_request, } - transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() response_value.status_code = 200 - pb_return_value = ekm_service.EkmConnection.pb(return_value) + pb_return_value = ekm_service.EkmConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.create_ekm_connection(request) + response = client.get_ekm_config(request) - expected_params = [ - ( - "ekmConnectionId", - "", - ), - ("$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_ekm_connection_rest_unset_required_fields(): +def test_get_ekm_config_rest_unset_required_fields(): transport = transports.EkmServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.create_ekm_connection._get_unset_required_fields({}) - assert set(unset_fields) == ( - set(("ekmConnectionId",)) - & set( - ( - "parent", - "ekmConnectionId", - "ekmConnection", - ) - ) - ) + unset_fields = transport.get_ekm_config._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_ekm_connection_rest_interceptors(null_interceptor): +def test_get_ekm_config_rest_interceptors(null_interceptor): transport = transports.EkmServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -2726,14 +3941,14 @@ def test_create_ekm_connection_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.EkmServiceRestInterceptor, "post_create_ekm_connection" + transports.EkmServiceRestInterceptor, "post_get_ekm_config" ) as post, mock.patch.object( - transports.EkmServiceRestInterceptor, "pre_create_ekm_connection" + transports.EkmServiceRestInterceptor, "pre_get_ekm_config" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = ekm_service.CreateEkmConnectionRequest.pb( - ekm_service.CreateEkmConnectionRequest() + pb_message = ekm_service.GetEkmConfigRequest.pb( + ekm_service.GetEkmConfigRequest() ) transcode.return_value = { "method": "post", @@ -2745,19 +3960,19 @@ def test_create_ekm_connection_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = ekm_service.EkmConnection.to_json( - ekm_service.EkmConnection() + req.return_value._content = ekm_service.EkmConfig.to_json( + ekm_service.EkmConfig() ) - request = ekm_service.CreateEkmConnectionRequest() + request = ekm_service.GetEkmConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = ekm_service.EkmConnection() + post.return_value = ekm_service.EkmConfig() - client.create_ekm_connection( + client.get_ekm_config( request, metadata=[ ("key", "val"), @@ -2769,8 +3984,8 @@ def test_create_ekm_connection_rest_interceptors(null_interceptor): post.assert_called_once() -def test_create_ekm_connection_rest_bad_request( - transport: str = "rest", request_type=ekm_service.CreateEkmConnectionRequest +def test_get_ekm_config_rest_bad_request( + transport: str = "rest", request_type=ekm_service.GetEkmConfigRequest ): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -2778,35 +3993,7 @@ def test_create_ekm_connection_rest_bad_request( ) # send a request that will satisfy transcoding - request_init = {"parent": "projects/sample1/locations/sample2"} - request_init["ekm_connection"] = { - "name": "name_value", - "create_time": {"seconds": 751, "nanos": 543}, - "service_resolvers": [ - { - "service_directory_service": "service_directory_service_value", - "endpoint_filter": "endpoint_filter_value", - "hostname": "hostname_value", - "server_certificates": [ - { - "raw_der": b"raw_der_blob", - "parsed": True, - "issuer": "issuer_value", - "subject": "subject_value", - "subject_alternative_dns_names": [ - "subject_alternative_dns_names_value1", - "subject_alternative_dns_names_value2", - ], - "not_before_time": {}, - "not_after_time": {}, - "serial_number": "serial_number_value", - "sha256_fingerprint": "sha256_fingerprint_value", - } - ], - } - ], - "etag": "etag_value", - } + request_init = {"name": "projects/sample1/locations/sample2/ekmConfig"} request = request_type(**request_init) # Mock the http request call within the method and fake a BadRequest error. @@ -2818,10 +4005,10 @@ def test_create_ekm_connection_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.create_ekm_connection(request) + client.get_ekm_config(request) -def test_create_ekm_connection_rest_flattened(): +def test_get_ekm_config_rest_flattened(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -2830,41 +4017,38 @@ def test_create_ekm_connection_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 = ekm_service.EkmConnection() + return_value = ekm_service.EkmConfig() # get arguments that satisfy an http rule for this method - sample_request = {"parent": "projects/sample1/locations/sample2"} + sample_request = {"name": "projects/sample1/locations/sample2/ekmConfig"} # get truthy value for each flattened field mock_args = dict( - parent="parent_value", - ekm_connection_id="ekm_connection_id_value", - ekm_connection=ekm_service.EkmConnection(name="name_value"), + name="name_value", ) mock_args.update(sample_request) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = ekm_service.EkmConnection.pb(return_value) + pb_return_value = ekm_service.EkmConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.create_ekm_connection(**mock_args) + client.get_ekm_config(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{parent=projects/*/locations/*}/ekmConnections" - % client.transport._host, + "%s/v1/{name=projects/*/locations/*/ekmConfig}" % client.transport._host, args[1], ) -def test_create_ekm_connection_rest_flattened_error(transport: str = "rest"): +def test_get_ekm_config_rest_flattened_error(transport: str = "rest"): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -2873,15 +4057,13 @@ def test_create_ekm_connection_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_ekm_connection( - ekm_service.CreateEkmConnectionRequest(), - parent="parent_value", - ekm_connection_id="ekm_connection_id_value", - ekm_connection=ekm_service.EkmConnection(name="name_value"), + client.get_ekm_config( + ekm_service.GetEkmConfigRequest(), + name="name_value", ) -def test_create_ekm_connection_rest_error(): +def test_get_ekm_config_rest_error(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -2890,11 +4072,11 @@ def test_create_ekm_connection_rest_error(): @pytest.mark.parametrize( "request_type", [ - ekm_service.UpdateEkmConnectionRequest, + ekm_service.UpdateEkmConfigRequest, dict, ], ) -def test_update_ekm_connection_rest(request_type): +def test_update_ekm_config_rest(request_type): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -2902,66 +4084,40 @@ def test_update_ekm_connection_rest(request_type): # send a request that will satisfy transcoding request_init = { - "ekm_connection": { - "name": "projects/sample1/locations/sample2/ekmConnections/sample3" - } + "ekm_config": {"name": "projects/sample1/locations/sample2/ekmConfig"} } - request_init["ekm_connection"] = { - "name": "projects/sample1/locations/sample2/ekmConnections/sample3", - "create_time": {"seconds": 751, "nanos": 543}, - "service_resolvers": [ - { - "service_directory_service": "service_directory_service_value", - "endpoint_filter": "endpoint_filter_value", - "hostname": "hostname_value", - "server_certificates": [ - { - "raw_der": b"raw_der_blob", - "parsed": True, - "issuer": "issuer_value", - "subject": "subject_value", - "subject_alternative_dns_names": [ - "subject_alternative_dns_names_value1", - "subject_alternative_dns_names_value2", - ], - "not_before_time": {}, - "not_after_time": {}, - "serial_number": "serial_number_value", - "sha256_fingerprint": "sha256_fingerprint_value", - } - ], - } - ], - "etag": "etag_value", + request_init["ekm_config"] = { + "name": "projects/sample1/locations/sample2/ekmConfig", + "default_ekm_connection": "default_ekm_connection_value", } request = request_type(**request_init) # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = ekm_service.EkmConnection( + return_value = ekm_service.EkmConfig( name="name_value", - etag="etag_value", + default_ekm_connection="default_ekm_connection_value", ) # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = ekm_service.EkmConnection.pb(return_value) + pb_return_value = ekm_service.EkmConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_ekm_connection(request) + response = client.update_ekm_config(request) # Establish that the response is the type that we expect. - assert isinstance(response, ekm_service.EkmConnection) + assert isinstance(response, ekm_service.EkmConfig) assert response.name == "name_value" - assert response.etag == "etag_value" + assert response.default_ekm_connection == "default_ekm_connection_value" -def test_update_ekm_connection_rest_required_fields( - request_type=ekm_service.UpdateEkmConnectionRequest, +def test_update_ekm_config_rest_required_fields( + request_type=ekm_service.UpdateEkmConfigRequest, ): transport_class = transports.EkmServiceRestTransport @@ -2980,14 +4136,14 @@ def test_update_ekm_connection_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_ekm_connection._get_unset_required_fields(jsonified_request) + ).update_ekm_config._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_ekm_connection._get_unset_required_fields(jsonified_request) + ).update_ekm_config._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. assert not set(unset_fields) - set(("update_mask",)) jsonified_request.update(unset_fields) @@ -3001,7 +4157,7 @@ def test_update_ekm_connection_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = ekm_service.EkmConnection() + return_value = ekm_service.EkmConfig() # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -3022,30 +4178,30 @@ def test_update_ekm_connection_rest_required_fields( response_value = Response() response_value.status_code = 200 - pb_return_value = ekm_service.EkmConnection.pb(return_value) + pb_return_value = ekm_service.EkmConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - response = client.update_ekm_connection(request) + response = client.update_ekm_config(request) expected_params = [("$alt", "json;enum-encoding=int")] actual_params = req.call_args.kwargs["params"] assert expected_params == actual_params -def test_update_ekm_connection_rest_unset_required_fields(): +def test_update_ekm_config_rest_unset_required_fields(): transport = transports.EkmServiceRestTransport( credentials=ga_credentials.AnonymousCredentials ) - unset_fields = transport.update_ekm_connection._get_unset_required_fields({}) + unset_fields = transport.update_ekm_config._get_unset_required_fields({}) assert set(unset_fields) == ( set(("updateMask",)) & set( ( - "ekmConnection", + "ekmConfig", "updateMask", ) ) @@ -3053,7 +4209,7 @@ def test_update_ekm_connection_rest_unset_required_fields(): @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_update_ekm_connection_rest_interceptors(null_interceptor): +def test_update_ekm_config_rest_interceptors(null_interceptor): transport = transports.EkmServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -3066,14 +4222,14 @@ def test_update_ekm_connection_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.EkmServiceRestInterceptor, "post_update_ekm_connection" + transports.EkmServiceRestInterceptor, "post_update_ekm_config" ) as post, mock.patch.object( - transports.EkmServiceRestInterceptor, "pre_update_ekm_connection" + transports.EkmServiceRestInterceptor, "pre_update_ekm_config" ) as pre: pre.assert_not_called() post.assert_not_called() - pb_message = ekm_service.UpdateEkmConnectionRequest.pb( - ekm_service.UpdateEkmConnectionRequest() + pb_message = ekm_service.UpdateEkmConfigRequest.pb( + ekm_service.UpdateEkmConfigRequest() ) transcode.return_value = { "method": "post", @@ -3085,19 +4241,19 @@ def test_update_ekm_connection_rest_interceptors(null_interceptor): req.return_value = Response() req.return_value.status_code = 200 req.return_value.request = PreparedRequest() - req.return_value._content = ekm_service.EkmConnection.to_json( - ekm_service.EkmConnection() + req.return_value._content = ekm_service.EkmConfig.to_json( + ekm_service.EkmConfig() ) - request = ekm_service.UpdateEkmConnectionRequest() + request = ekm_service.UpdateEkmConfigRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = ekm_service.EkmConnection() + post.return_value = ekm_service.EkmConfig() - client.update_ekm_connection( + client.update_ekm_config( request, metadata=[ ("key", "val"), @@ -3109,8 +4265,8 @@ def test_update_ekm_connection_rest_interceptors(null_interceptor): post.assert_called_once() -def test_update_ekm_connection_rest_bad_request( - transport: str = "rest", request_type=ekm_service.UpdateEkmConnectionRequest +def test_update_ekm_config_rest_bad_request( + transport: str = "rest", request_type=ekm_service.UpdateEkmConfigRequest ): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -3119,37 +4275,11 @@ def test_update_ekm_connection_rest_bad_request( # send a request that will satisfy transcoding request_init = { - "ekm_connection": { - "name": "projects/sample1/locations/sample2/ekmConnections/sample3" - } + "ekm_config": {"name": "projects/sample1/locations/sample2/ekmConfig"} } - request_init["ekm_connection"] = { - "name": "projects/sample1/locations/sample2/ekmConnections/sample3", - "create_time": {"seconds": 751, "nanos": 543}, - "service_resolvers": [ - { - "service_directory_service": "service_directory_service_value", - "endpoint_filter": "endpoint_filter_value", - "hostname": "hostname_value", - "server_certificates": [ - { - "raw_der": b"raw_der_blob", - "parsed": True, - "issuer": "issuer_value", - "subject": "subject_value", - "subject_alternative_dns_names": [ - "subject_alternative_dns_names_value1", - "subject_alternative_dns_names_value2", - ], - "not_before_time": {}, - "not_after_time": {}, - "serial_number": "serial_number_value", - "sha256_fingerprint": "sha256_fingerprint_value", - } - ], - } - ], - "etag": "etag_value", + request_init["ekm_config"] = { + "name": "projects/sample1/locations/sample2/ekmConfig", + "default_ekm_connection": "default_ekm_connection_value", } request = request_type(**request_init) @@ -3162,10 +4292,10 @@ def test_update_ekm_connection_rest_bad_request( response_value.status_code = 400 response_value.request = Request() req.return_value = response_value - client.update_ekm_connection(request) + client.update_ekm_config(request) -def test_update_ekm_connection_rest_flattened(): +def test_update_ekm_config_rest_flattened(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest", @@ -3174,18 +4304,16 @@ def test_update_ekm_connection_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 = ekm_service.EkmConnection() + return_value = ekm_service.EkmConfig() # get arguments that satisfy an http rule for this method sample_request = { - "ekm_connection": { - "name": "projects/sample1/locations/sample2/ekmConnections/sample3" - } + "ekm_config": {"name": "projects/sample1/locations/sample2/ekmConfig"} } # get truthy value for each flattened field mock_args = dict( - ekm_connection=ekm_service.EkmConnection(name="name_value"), + ekm_config=ekm_service.EkmConfig(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) mock_args.update(sample_request) @@ -3193,25 +4321,25 @@ def test_update_ekm_connection_rest_flattened(): # Wrap the value into a proper Response obj response_value = Response() response_value.status_code = 200 - pb_return_value = ekm_service.EkmConnection.pb(return_value) + pb_return_value = ekm_service.EkmConfig.pb(return_value) json_return_value = json_format.MessageToJson(pb_return_value) response_value._content = json_return_value.encode("UTF-8") req.return_value = response_value - client.update_ekm_connection(**mock_args) + client.update_ekm_config(**mock_args) # Establish that the underlying call was made with the expected # request object values. assert len(req.mock_calls) == 1 _, args, _ = req.mock_calls[0] assert path_template.validate( - "%s/v1/{ekm_connection.name=projects/*/locations/*/ekmConnections/*}" + "%s/v1/{ekm_config.name=projects/*/locations/*/ekmConfig}" % client.transport._host, args[1], ) -def test_update_ekm_connection_rest_flattened_error(transport: str = "rest"): +def test_update_ekm_config_rest_flattened_error(transport: str = "rest"): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -3220,14 +4348,14 @@ def test_update_ekm_connection_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_ekm_connection( - ekm_service.UpdateEkmConnectionRequest(), - ekm_connection=ekm_service.EkmConnection(name="name_value"), + client.update_ekm_config( + ekm_service.UpdateEkmConfigRequest(), + ekm_config=ekm_service.EkmConfig(name="name_value"), update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), ) -def test_update_ekm_connection_rest_error(): +def test_update_ekm_config_rest_error(): client = EkmServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -3376,6 +4504,8 @@ def test_ekm_service_base_transport(): "get_ekm_connection", "create_ekm_connection", "update_ekm_connection", + "get_ekm_config", + "update_ekm_config", "set_iam_policy", "get_iam_policy", "test_iam_permissions", @@ -3660,6 +4790,12 @@ def test_ekm_service_client_transport_session_collision(transport_name): session1 = client1.transport.update_ekm_connection._session session2 = client2.transport.update_ekm_connection._session assert session1 != session2 + session1 = client1.transport.get_ekm_config._session + session2 = client2.transport.get_ekm_config._session + assert session1 != session2 + session1 = client1.transport.update_ekm_config._session + session2 = client2.transport.update_ekm_config._session + assert session1 != session2 def test_ekm_service_grpc_transport_channel(): @@ -3780,10 +4916,33 @@ def test_ekm_service_transport_channel_mtls_with_adc(transport_class): assert transport.grpc_channel == mock_grpc_channel -def test_ekm_connection_path(): +def test_ekm_config_path(): project = "squid" location = "clam" - ekm_connection = "whelk" + expected = "projects/{project}/locations/{location}/ekmConfig".format( + project=project, + location=location, + ) + actual = EkmServiceClient.ekm_config_path(project, location) + assert expected == actual + + +def test_parse_ekm_config_path(): + expected = { + "project": "whelk", + "location": "octopus", + } + path = EkmServiceClient.ekm_config_path(**expected) + + # Check that the path construction is reversible. + actual = EkmServiceClient.parse_ekm_config_path(path) + assert expected == actual + + +def test_ekm_connection_path(): + project = "oyster" + location = "nudibranch" + ekm_connection = "cuttlefish" expected = "projects/{project}/locations/{location}/ekmConnections/{ekm_connection}".format( project=project, location=location, @@ -3795,9 +4954,9 @@ def test_ekm_connection_path(): def test_parse_ekm_connection_path(): expected = { - "project": "octopus", - "location": "oyster", - "ekm_connection": "nudibranch", + "project": "mussel", + "location": "winkle", + "ekm_connection": "nautilus", } path = EkmServiceClient.ekm_connection_path(**expected) @@ -3807,10 +4966,10 @@ def test_parse_ekm_connection_path(): def test_service_path(): - project = "cuttlefish" - location = "mussel" - namespace = "winkle" - service = "nautilus" + project = "scallop" + location = "abalone" + namespace = "squid" + service = "clam" expected = "projects/{project}/locations/{location}/namespaces/{namespace}/services/{service}".format( project=project, location=location, @@ -3823,10 +4982,10 @@ def test_service_path(): def test_parse_service_path(): expected = { - "project": "scallop", - "location": "abalone", - "namespace": "squid", - "service": "clam", + "project": "whelk", + "location": "octopus", + "namespace": "oyster", + "service": "nudibranch", } path = EkmServiceClient.service_path(**expected) @@ -3836,7 +4995,7 @@ def test_parse_service_path(): def test_common_billing_account_path(): - billing_account = "whelk" + billing_account = "cuttlefish" expected = "billingAccounts/{billing_account}".format( billing_account=billing_account, ) @@ -3846,7 +5005,7 @@ def test_common_billing_account_path(): def test_parse_common_billing_account_path(): expected = { - "billing_account": "octopus", + "billing_account": "mussel", } path = EkmServiceClient.common_billing_account_path(**expected) @@ -3856,7 +5015,7 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): - folder = "oyster" + folder = "winkle" expected = "folders/{folder}".format( folder=folder, ) @@ -3866,7 +5025,7 @@ def test_common_folder_path(): def test_parse_common_folder_path(): expected = { - "folder": "nudibranch", + "folder": "nautilus", } path = EkmServiceClient.common_folder_path(**expected) @@ -3876,7 +5035,7 @@ def test_parse_common_folder_path(): def test_common_organization_path(): - organization = "cuttlefish" + organization = "scallop" expected = "organizations/{organization}".format( organization=organization, ) @@ -3886,7 +5045,7 @@ def test_common_organization_path(): def test_parse_common_organization_path(): expected = { - "organization": "mussel", + "organization": "abalone", } path = EkmServiceClient.common_organization_path(**expected) @@ -3896,7 +5055,7 @@ def test_parse_common_organization_path(): def test_common_project_path(): - project = "winkle" + project = "squid" expected = "projects/{project}".format( project=project, ) @@ -3906,7 +5065,7 @@ def test_common_project_path(): def test_parse_common_project_path(): expected = { - "project": "nautilus", + "project": "clam", } path = EkmServiceClient.common_project_path(**expected) @@ -3916,8 +5075,8 @@ def test_parse_common_project_path(): def test_common_location_path(): - project = "scallop" - location = "abalone" + project = "whelk" + location = "octopus" expected = "projects/{project}/locations/{location}".format( project=project, location=location, @@ -3928,8 +5087,8 @@ def test_common_location_path(): def test_parse_common_location_path(): expected = { - "project": "squid", - "location": "clam", + "project": "oyster", + "location": "nudibranch", } path = EkmServiceClient.common_location_path(**expected) diff --git a/tests/unit/gapic/kms_v1/test_key_management_service.py b/tests/unit/gapic/kms_v1/test_key_management_service.py index e08d0330..ae3c7745 100644 --- a/tests/unit/gapic/kms_v1/test_key_management_service.py +++ b/tests/unit/gapic/kms_v1/test_key_management_service.py @@ -2975,6 +2975,8 @@ def test_get_crypto_key_version(request_type, transport: str = "grpc"): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) response = client.get_crypto_key_version(request) @@ -2998,6 +3000,11 @@ def test_get_crypto_key_version(request_type, transport: str = "grpc"): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -3045,6 +3052,8 @@ async def test_get_crypto_key_version_async( algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) ) @@ -3069,6 +3078,11 @@ async def test_get_crypto_key_version_async( ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -4272,6 +4286,8 @@ def test_create_crypto_key_version(request_type, transport: str = "grpc"): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) response = client.create_crypto_key_version(request) @@ -4295,6 +4311,11 @@ def test_create_crypto_key_version(request_type, transport: str = "grpc"): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -4342,6 +4363,8 @@ async def test_create_crypto_key_version_async( algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) ) @@ -4366,6 +4389,11 @@ async def test_create_crypto_key_version_async( ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -4564,6 +4592,8 @@ def test_import_crypto_key_version(request_type, transport: str = "grpc"): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) response = client.import_crypto_key_version(request) @@ -4587,6 +4617,11 @@ def test_import_crypto_key_version(request_type, transport: str = "grpc"): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -4634,6 +4669,8 @@ async def test_import_crypto_key_version_async( algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) ) @@ -4658,6 +4695,11 @@ async def test_import_crypto_key_version_async( ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -5305,6 +5347,8 @@ def test_update_crypto_key_version(request_type, transport: str = "grpc"): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) response = client.update_crypto_key_version(request) @@ -5328,6 +5372,11 @@ def test_update_crypto_key_version(request_type, transport: str = "grpc"): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -5375,6 +5424,8 @@ async def test_update_crypto_key_version_async( algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) ) @@ -5399,6 +5450,11 @@ async def test_update_crypto_key_version_async( ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -5863,6 +5919,8 @@ def test_destroy_crypto_key_version(request_type, transport: str = "grpc"): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) response = client.destroy_crypto_key_version(request) @@ -5886,6 +5944,11 @@ def test_destroy_crypto_key_version(request_type, transport: str = "grpc"): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -5933,6 +5996,8 @@ async def test_destroy_crypto_key_version_async( algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) ) @@ -5957,6 +6022,11 @@ async def test_destroy_crypto_key_version_async( ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -6145,6 +6215,8 @@ def test_restore_crypto_key_version(request_type, transport: str = "grpc"): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) response = client.restore_crypto_key_version(request) @@ -6168,6 +6240,11 @@ def test_restore_crypto_key_version(request_type, transport: str = "grpc"): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -6215,6 +6292,8 @@ async def test_restore_crypto_key_version_async( algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) ) @@ -6239,6 +6318,11 @@ async def test_restore_crypto_key_version_async( ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -10174,6 +10258,8 @@ def test_get_crypto_key_version_rest(request_type): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) @@ -10201,6 +10287,11 @@ def test_get_crypto_key_version_rest(request_type): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -11335,6 +11426,8 @@ def test_create_crypto_key_rest(request_type): "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -11595,6 +11688,8 @@ def test_create_crypto_key_rest_bad_request( "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -11737,6 +11832,8 @@ def test_create_crypto_key_version_rest(request_type): "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -11755,6 +11852,8 @@ def test_create_crypto_key_version_rest(request_type): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) @@ -11782,6 +11881,11 @@ def test_create_crypto_key_version_rest(request_type): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -11976,6 +12080,8 @@ def test_create_crypto_key_version_rest_bad_request( "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -12091,6 +12197,8 @@ def test_import_crypto_key_version_rest(request_type): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) @@ -12118,6 +12226,11 @@ def test_import_crypto_key_version_rest(request_type): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -12714,6 +12827,8 @@ def test_update_crypto_key_rest(request_type): "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -12949,6 +13064,8 @@ def test_update_crypto_key_rest_bad_request( "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -13093,6 +13210,8 @@ def test_update_crypto_key_version_rest(request_type): "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -13111,6 +13230,8 @@ def test_update_crypto_key_version_rest(request_type): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) @@ -13138,6 +13259,11 @@ def test_update_crypto_key_version_rest(request_type): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -13331,6 +13457,8 @@ def test_update_crypto_key_version_rest_bad_request( "import_job": "import_job_value", "import_time": {}, "import_failure_reason": "import_failure_reason_value", + "generation_failure_reason": "generation_failure_reason_value", + "external_destruction_failure_reason": "external_destruction_failure_reason_value", "external_protection_level_options": { "external_key_uri": "external_key_uri_value", "ekm_connection_key_path": "ekm_connection_key_path_value", @@ -13748,6 +13876,8 @@ def test_destroy_crypto_key_version_rest(request_type): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) @@ -13775,6 +13905,11 @@ def test_destroy_crypto_key_version_rest(request_type): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True @@ -14042,6 +14177,8 @@ def test_restore_crypto_key_version_rest(request_type): algorithm=resources.CryptoKeyVersion.CryptoKeyVersionAlgorithm.GOOGLE_SYMMETRIC_ENCRYPTION, import_job="import_job_value", import_failure_reason="import_failure_reason_value", + generation_failure_reason="generation_failure_reason_value", + external_destruction_failure_reason="external_destruction_failure_reason_value", reimport_eligible=True, ) @@ -14069,6 +14206,11 @@ def test_restore_crypto_key_version_rest(request_type): ) assert response.import_job == "import_job_value" assert response.import_failure_reason == "import_failure_reason_value" + assert response.generation_failure_reason == "generation_failure_reason_value" + assert ( + response.external_destruction_failure_reason + == "external_destruction_failure_reason_value" + ) assert response.reimport_eligible is True