diff --git a/docs/domains_v1/domains.rst b/docs/domains_v1/domains.rst new file mode 100644 index 0000000..bfb140d --- /dev/null +++ b/docs/domains_v1/domains.rst @@ -0,0 +1,10 @@ +Domains +------------------------- + +.. automodule:: google.cloud.domains_v1.services.domains + :members: + :inherited-members: + +.. automodule:: google.cloud.domains_v1.services.domains.pagers + :members: + :inherited-members: diff --git a/docs/domains_v1/services.rst b/docs/domains_v1/services.rst new file mode 100644 index 0000000..1073e86 --- /dev/null +++ b/docs/domains_v1/services.rst @@ -0,0 +1,6 @@ +Services for Google Cloud Domains v1 API +======================================== +.. toctree:: + :maxdepth: 2 + + domains diff --git a/docs/domains_v1/types.rst b/docs/domains_v1/types.rst new file mode 100644 index 0000000..813716b --- /dev/null +++ b/docs/domains_v1/types.rst @@ -0,0 +1,7 @@ +Types for Google Cloud Domains v1 API +===================================== + +.. automodule:: google.cloud.domains_v1.types + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/index.rst b/docs/index.rst index 4985065..9081d62 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,6 +2,9 @@ .. include:: multiprocessing.rst +This package includes clients for multiple versions of Cloud Domains. +By default, you will get version ``domains_v1beta1``. + API Reference ------------- @@ -11,6 +14,14 @@ API Reference domains_v1beta1/services domains_v1beta1/types +API Reference +------------- +.. toctree:: + :maxdepth: 2 + + domains_v1/services + domains_v1/types + Changelog --------- diff --git a/google/cloud/domains/__init__.py b/google/cloud/domains/__init__.py index c65bbe7..c6408e9 100644 --- a/google/cloud/domains/__init__.py +++ b/google/cloud/domains/__init__.py @@ -43,8 +43,14 @@ from google.cloud.domains_v1beta1.types.domains import ( RetrieveRegisterParametersResponse, ) +from google.cloud.domains_v1beta1.types.domains import RetrieveTransferParametersRequest +from google.cloud.domains_v1beta1.types.domains import ( + RetrieveTransferParametersResponse, +) from google.cloud.domains_v1beta1.types.domains import SearchDomainsRequest from google.cloud.domains_v1beta1.types.domains import SearchDomainsResponse +from google.cloud.domains_v1beta1.types.domains import TransferDomainRequest +from google.cloud.domains_v1beta1.types.domains import TransferParameters from google.cloud.domains_v1beta1.types.domains import UpdateRegistrationRequest from google.cloud.domains_v1beta1.types.domains import ContactNotice from google.cloud.domains_v1beta1.types.domains import ContactPrivacy @@ -74,8 +80,12 @@ "RetrieveAuthorizationCodeRequest", "RetrieveRegisterParametersRequest", "RetrieveRegisterParametersResponse", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", "SearchDomainsRequest", "SearchDomainsResponse", + "TransferDomainRequest", + "TransferParameters", "UpdateRegistrationRequest", "ContactNotice", "ContactPrivacy", diff --git a/google/cloud/domains_v1/__init__.py b/google/cloud/domains_v1/__init__.py new file mode 100644 index 0000000..10f2983 --- /dev/null +++ b/google/cloud/domains_v1/__init__.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +from .services.domains import DomainsClient +from .services.domains import DomainsAsyncClient + +from .types.domains import AuthorizationCode +from .types.domains import ConfigureContactSettingsRequest +from .types.domains import ConfigureDnsSettingsRequest +from .types.domains import ConfigureManagementSettingsRequest +from .types.domains import ContactSettings +from .types.domains import DeleteRegistrationRequest +from .types.domains import DnsSettings +from .types.domains import ExportRegistrationRequest +from .types.domains import GetRegistrationRequest +from .types.domains import ListRegistrationsRequest +from .types.domains import ListRegistrationsResponse +from .types.domains import ManagementSettings +from .types.domains import OperationMetadata +from .types.domains import RegisterDomainRequest +from .types.domains import RegisterParameters +from .types.domains import Registration +from .types.domains import ResetAuthorizationCodeRequest +from .types.domains import RetrieveAuthorizationCodeRequest +from .types.domains import RetrieveRegisterParametersRequest +from .types.domains import RetrieveRegisterParametersResponse +from .types.domains import RetrieveTransferParametersRequest +from .types.domains import RetrieveTransferParametersResponse +from .types.domains import SearchDomainsRequest +from .types.domains import SearchDomainsResponse +from .types.domains import TransferDomainRequest +from .types.domains import TransferParameters +from .types.domains import UpdateRegistrationRequest +from .types.domains import ContactNotice +from .types.domains import ContactPrivacy +from .types.domains import DomainNotice +from .types.domains import TransferLockState + +__all__ = ( + "DomainsAsyncClient", + "AuthorizationCode", + "ConfigureContactSettingsRequest", + "ConfigureDnsSettingsRequest", + "ConfigureManagementSettingsRequest", + "ContactNotice", + "ContactPrivacy", + "ContactSettings", + "DeleteRegistrationRequest", + "DnsSettings", + "DomainNotice", + "DomainsClient", + "ExportRegistrationRequest", + "GetRegistrationRequest", + "ListRegistrationsRequest", + "ListRegistrationsResponse", + "ManagementSettings", + "OperationMetadata", + "RegisterDomainRequest", + "RegisterParameters", + "Registration", + "ResetAuthorizationCodeRequest", + "RetrieveAuthorizationCodeRequest", + "RetrieveRegisterParametersRequest", + "RetrieveRegisterParametersResponse", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", + "SearchDomainsRequest", + "SearchDomainsResponse", + "TransferDomainRequest", + "TransferLockState", + "TransferParameters", + "UpdateRegistrationRequest", +) diff --git a/google/cloud/domains_v1/gapic_metadata.json b/google/cloud/domains_v1/gapic_metadata.json new file mode 100644 index 0000000..c6b54de --- /dev/null +++ b/google/cloud/domains_v1/gapic_metadata.json @@ -0,0 +1,173 @@ + { + "comment": "This file maps proto services/RPCs to the corresponding library clients/methods", + "language": "python", + "libraryPackage": "google.cloud.domains_v1", + "protoPackage": "google.cloud.domains.v1", + "schema": "1.0", + "services": { + "Domains": { + "clients": { + "grpc": { + "libraryClient": "DomainsClient", + "rpcs": { + "ConfigureContactSettings": { + "methods": [ + "configure_contact_settings" + ] + }, + "ConfigureDnsSettings": { + "methods": [ + "configure_dns_settings" + ] + }, + "ConfigureManagementSettings": { + "methods": [ + "configure_management_settings" + ] + }, + "DeleteRegistration": { + "methods": [ + "delete_registration" + ] + }, + "ExportRegistration": { + "methods": [ + "export_registration" + ] + }, + "GetRegistration": { + "methods": [ + "get_registration" + ] + }, + "ListRegistrations": { + "methods": [ + "list_registrations" + ] + }, + "RegisterDomain": { + "methods": [ + "register_domain" + ] + }, + "ResetAuthorizationCode": { + "methods": [ + "reset_authorization_code" + ] + }, + "RetrieveAuthorizationCode": { + "methods": [ + "retrieve_authorization_code" + ] + }, + "RetrieveRegisterParameters": { + "methods": [ + "retrieve_register_parameters" + ] + }, + "RetrieveTransferParameters": { + "methods": [ + "retrieve_transfer_parameters" + ] + }, + "SearchDomains": { + "methods": [ + "search_domains" + ] + }, + "TransferDomain": { + "methods": [ + "transfer_domain" + ] + }, + "UpdateRegistration": { + "methods": [ + "update_registration" + ] + } + } + }, + "grpc-async": { + "libraryClient": "DomainsAsyncClient", + "rpcs": { + "ConfigureContactSettings": { + "methods": [ + "configure_contact_settings" + ] + }, + "ConfigureDnsSettings": { + "methods": [ + "configure_dns_settings" + ] + }, + "ConfigureManagementSettings": { + "methods": [ + "configure_management_settings" + ] + }, + "DeleteRegistration": { + "methods": [ + "delete_registration" + ] + }, + "ExportRegistration": { + "methods": [ + "export_registration" + ] + }, + "GetRegistration": { + "methods": [ + "get_registration" + ] + }, + "ListRegistrations": { + "methods": [ + "list_registrations" + ] + }, + "RegisterDomain": { + "methods": [ + "register_domain" + ] + }, + "ResetAuthorizationCode": { + "methods": [ + "reset_authorization_code" + ] + }, + "RetrieveAuthorizationCode": { + "methods": [ + "retrieve_authorization_code" + ] + }, + "RetrieveRegisterParameters": { + "methods": [ + "retrieve_register_parameters" + ] + }, + "RetrieveTransferParameters": { + "methods": [ + "retrieve_transfer_parameters" + ] + }, + "SearchDomains": { + "methods": [ + "search_domains" + ] + }, + "TransferDomain": { + "methods": [ + "transfer_domain" + ] + }, + "UpdateRegistration": { + "methods": [ + "update_registration" + ] + } + } + } + } + } + } +} diff --git a/google/cloud/domains_v1/py.typed b/google/cloud/domains_v1/py.typed new file mode 100644 index 0000000..b463d6c --- /dev/null +++ b/google/cloud/domains_v1/py.typed @@ -0,0 +1,2 @@ +# Marker file for PEP 561. +# The google-cloud-domains package uses inline types. diff --git a/google/cloud/domains_v1/services/__init__.py b/google/cloud/domains_v1/services/__init__.py new file mode 100644 index 0000000..4de6597 --- /dev/null +++ b/google/cloud/domains_v1/services/__init__.py @@ -0,0 +1,15 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 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. +# diff --git a/google/cloud/domains_v1/services/domains/__init__.py b/google/cloud/domains_v1/services/domains/__init__.py new file mode 100644 index 0000000..cd7bb44 --- /dev/null +++ b/google/cloud/domains_v1/services/domains/__init__.py @@ -0,0 +1,22 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from .client import DomainsClient +from .async_client import DomainsAsyncClient + +__all__ = ( + "DomainsClient", + "DomainsAsyncClient", +) diff --git a/google/cloud/domains_v1/services/domains/async_client.py b/google/cloud/domains_v1/services/domains/async_client.py new file mode 100644 index 0000000..9a293f0 --- /dev/null +++ b/google/cloud/domains_v1/services/domains/async_client.py @@ -0,0 +1,1779 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +import functools +import re +from typing import Dict, Sequence, Tuple, Type, Union +import pkg_resources + +import google.api_core.client_options as ClientOptions # type: ignore +from google.api_core import exceptions as core_exceptions # type: ignore +from google.api_core import gapic_v1 # type: ignore +from google.api_core import retry as retries # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.oauth2 import service_account # type: ignore + +from google.api_core import operation # type: ignore +from google.api_core import operation_async # type: ignore +from google.cloud.domains_v1.services.domains import pagers +from google.cloud.domains_v1.types import domains +from google.protobuf import empty_pb2 # type: ignore +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore +from google.type import money_pb2 # type: ignore +from .transports.base import DomainsTransport, DEFAULT_CLIENT_INFO +from .transports.grpc_asyncio import DomainsGrpcAsyncIOTransport +from .client import DomainsClient + + +class DomainsAsyncClient: + """The Cloud Domains API enables management and configuration of + domain names. + """ + + _client: DomainsClient + + DEFAULT_ENDPOINT = DomainsClient.DEFAULT_ENDPOINT + DEFAULT_MTLS_ENDPOINT = DomainsClient.DEFAULT_MTLS_ENDPOINT + + registration_path = staticmethod(DomainsClient.registration_path) + parse_registration_path = staticmethod(DomainsClient.parse_registration_path) + common_billing_account_path = staticmethod( + DomainsClient.common_billing_account_path + ) + parse_common_billing_account_path = staticmethod( + DomainsClient.parse_common_billing_account_path + ) + common_folder_path = staticmethod(DomainsClient.common_folder_path) + parse_common_folder_path = staticmethod(DomainsClient.parse_common_folder_path) + common_organization_path = staticmethod(DomainsClient.common_organization_path) + parse_common_organization_path = staticmethod( + DomainsClient.parse_common_organization_path + ) + common_project_path = staticmethod(DomainsClient.common_project_path) + parse_common_project_path = staticmethod(DomainsClient.parse_common_project_path) + common_location_path = staticmethod(DomainsClient.common_location_path) + parse_common_location_path = staticmethod(DomainsClient.parse_common_location_path) + + @classmethod + def from_service_account_info(cls, info: dict, *args, **kwargs): + """Creates an instance of this client using the provided credentials + info. + + Args: + info (dict): The service account private key info. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + DomainsAsyncClient: The constructed client. + """ + return DomainsClient.from_service_account_info.__func__(DomainsAsyncClient, info, *args, **kwargs) # type: ignore + + @classmethod + def from_service_account_file(cls, filename: str, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + DomainsAsyncClient: The constructed client. + """ + return DomainsClient.from_service_account_file.__func__(DomainsAsyncClient, filename, *args, **kwargs) # type: ignore + + from_service_account_json = from_service_account_file + + @property + def transport(self) -> DomainsTransport: + """Returns the transport used by the client instance. + + Returns: + DomainsTransport: The transport used by the client instance. + """ + return self._client.transport + + get_transport_class = functools.partial( + type(DomainsClient).get_transport_class, type(DomainsClient) + ) + + def __init__( + self, + *, + credentials: ga_credentials.Credentials = None, + transport: Union[str, DomainsTransport] = "grpc_asyncio", + client_options: ClientOptions = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + ) -> None: + """Instantiates the domains client. + + Args: + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + transport (Union[str, ~.DomainsTransport]): The + transport to use. If set to None, a transport is chosen + automatically. + client_options (ClientOptions): Custom options for the client. It + won't take effect if a ``transport`` instance is provided. + (1) The ``api_endpoint`` property can be used to override the + default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT + environment variable can also be used to override the endpoint: + "always" (always use the default mTLS endpoint), "never" (always + use the default regular endpoint) and "auto" (auto switch to the + default mTLS endpoint if client certificate is present, this is + the default value). However, the ``api_endpoint`` property takes + precedence if provided. + (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable + is "true", then the ``client_cert_source`` property can be used + to provide client certificate for mutual TLS transport. If + not provided, the default SSL client certificate will be used if + present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not + set, no client certificate will be used. + + Raises: + google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport + creation failed for any reason. + """ + self._client = DomainsClient( + credentials=credentials, + transport=transport, + client_options=client_options, + client_info=client_info, + ) + + async def search_domains( + self, + request: domains.SearchDomainsRequest = None, + *, + location: str = None, + query: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.SearchDomainsResponse: + r"""Searches for available domain names similar to the provided + query. + + Availability results from this method are approximate; call + ``RetrieveRegisterParameters`` on a domain before registering to + confirm availability. + + Args: + request (:class:`google.cloud.domains_v1.types.SearchDomainsRequest`): + The request object. Request for the `SearchDomains` + method. + location (:class:`str`): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + query (:class:`str`): + Required. String used to search for + available domain names. + + This corresponds to the ``query`` 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.domains_v1.types.SearchDomainsResponse: + Response for the SearchDomains method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, query]) + 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 = domains.SearchDomainsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if query is not None: + request.query = query + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.search_domains, + 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((("location", request.location),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + async def retrieve_register_parameters( + self, + request: domains.RetrieveRegisterParametersRequest = None, + *, + location: str = None, + domain_name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.RetrieveRegisterParametersResponse: + r"""Gets parameters needed to register a new domain name, including + price and up-to-date availability. Use the returned values to + call ``RegisterDomain``. + + Args: + request (:class:`google.cloud.domains_v1.types.RetrieveRegisterParametersRequest`): + The request object. Request for the + `RetrieveRegisterParameters` method. + location (:class:`str`): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + domain_name (:class:`str`): + Required. The domain name. Unicode + domain names must be expressed in + Punycode format. + + This corresponds to the ``domain_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.domains_v1.types.RetrieveRegisterParametersResponse: + Response for the RetrieveRegisterParameters method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, domain_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 = domains.RetrieveRegisterParametersRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if domain_name is not None: + request.domain_name = domain_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.retrieve_register_parameters, + 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((("location", request.location),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + async def register_domain( + self, + request: domains.RegisterDomainRequest = None, + *, + parent: str = None, + registration: domains.Registration = None, + yearly_price: money_pb2.Money = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Registers a new domain name and creates a corresponding + ``Registration`` resource. + + Call ``RetrieveRegisterParameters`` first to check availability + of the domain name and determine parameters like price that are + needed to build a call to this method. + + A successful call creates a ``Registration`` resource in state + ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within + 1-2 minutes, indicating that the domain was successfully + registered. If the resource ends up in state + ``REGISTRATION_FAILED``, it indicates that the domain was not + registered successfully, and you can safely delete the resource + and retry registration. + + Args: + request (:class:`google.cloud.domains_v1.types.RegisterDomainRequest`): + The request object. Request for the `RegisterDomain` + method. + parent (:class:`str`): + Required. The parent resource of the ``Registration``. + Must be in the format ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + registration (:class:`google.cloud.domains_v1.types.Registration`): + Required. The complete ``Registration`` resource to be + created. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + yearly_price (:class:`google.type.money_pb2.Money`): + Required. Yearly price to register or + renew the domain. The value that should + be put here can be obtained from + RetrieveRegisterParameters or + SearchDomains calls. + + This corresponds to the ``yearly_price`` 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([parent, registration, yearly_price]) + 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 = domains.RegisterDomainRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if registration is not None: + request.registration = registration + if yearly_price is not None: + request.yearly_price = yearly_price + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.register_domain, + 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((("parent", request.parent),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def retrieve_transfer_parameters( + self, + request: domains.RetrieveTransferParametersRequest = None, + *, + location: str = None, + domain_name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.RetrieveTransferParametersResponse: + r"""Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Args: + request (:class:`google.cloud.domains_v1.types.RetrieveTransferParametersRequest`): + The request object. Request for the + `RetrieveTransferParameters` method. + location (:class:`str`): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + domain_name (:class:`str`): + Required. The domain name. Unicode + domain names must be expressed in + Punycode format. + + This corresponds to the ``domain_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.domains_v1.types.RetrieveTransferParametersResponse: + Response for the RetrieveTransferParameters method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, domain_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 = domains.RetrieveTransferParametersRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if domain_name is not None: + request.domain_name = domain_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.retrieve_transfer_parameters, + 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((("location", request.location),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + async def transfer_domain( + self, + request: domains.TransferDomainRequest = None, + *, + parent: str = None, + registration: domains.Registration = None, + yearly_price: money_pb2.Money = None, + authorization_code: domains.AuthorizationCode = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Args: + request (:class:`google.cloud.domains_v1.types.TransferDomainRequest`): + The request object. Request for the `TransferDomain` + method. + parent (:class:`str`): + Required. The parent resource of the ``Registration``. + Must be in the format ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + registration (:class:`google.cloud.domains_v1.types.Registration`): + Required. The complete ``Registration`` resource to be + created. + + You can leave ``registration.dns_settings`` unset to + import the domain's current DNS configuration from its + current registrar. Use this option only if you are sure + that the domain's current DNS service does not cease + upon transfer, as is often the case for DNS services + provided for free by the registrar. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + yearly_price (:class:`google.type.money_pb2.Money`): + Required. Acknowledgement of the price to transfer or + renew the domain for one year. Call + ``RetrieveTransferParameters`` to obtain the price, + which you must acknowledge. + + This corresponds to the ``yearly_price`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + authorization_code (:class:`google.cloud.domains_v1.types.AuthorizationCode`): + The domain's transfer authorization + code. You can obtain this from the + domain's current registrar. + + This corresponds to the ``authorization_code`` 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any( + [parent, registration, yearly_price, authorization_code] + ) + 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 = domains.TransferDomainRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if registration is not None: + request.registration = registration + if yearly_price is not None: + request.yearly_price = yearly_price + if authorization_code is not None: + request.authorization_code = authorization_code + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.transfer_domain, + 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((("parent", request.parent),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def list_registrations( + self, + request: domains.ListRegistrationsRequest = None, + *, + parent: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListRegistrationsAsyncPager: + r"""Lists the ``Registration`` resources in a project. + + Args: + request (:class:`google.cloud.domains_v1.types.ListRegistrationsRequest`): + The request object. Request for the `ListRegistrations` + method. + parent (:class:`str`): + Required. The project and location from which to list + ``Registration``\ s, specified in the format + ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.cloud.domains_v1.services.domains.pagers.ListRegistrationsAsyncPager: + Response for the ListRegistrations method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([parent]) + 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 = domains.ListRegistrationsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.list_registrations, + 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((("parent", request.parent),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # This method is paged; wrap the response in a pager, which provides + # an `__aiter__` convenience method. + response = pagers.ListRegistrationsAsyncPager( + method=rpc, request=request, response=response, metadata=metadata, + ) + + # Done; return the response. + return response + + async def get_registration( + self, + request: domains.GetRegistrationRequest = None, + *, + name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.Registration: + r"""Gets the details of a ``Registration`` resource. + + Args: + request (:class:`google.cloud.domains_v1.types.GetRegistrationRequest`): + The request object. Request for the `GetRegistration` + method. + name (:class:`str`): + Required. The name of the ``Registration`` to get, in + the format ``projects/*/locations/*/registrations/*``. + + 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.domains_v1.types.Registration: + The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity 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 = domains.GetRegistrationRequest(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_registration, + 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_registration( + self, + request: domains.UpdateRegistrationRequest = None, + *, + registration: domains.Registration = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Updates select fields of a ``Registration`` resource, notably + ``labels``. To update other fields, use the appropriate custom + update method: + + - To update management settings, see + ``ConfigureManagementSettings`` + - To update DNS configuration, see ``ConfigureDnsSettings`` + - To update contact information, see + ``ConfigureContactSettings`` + + Args: + request (:class:`google.cloud.domains_v1.types.UpdateRegistrationRequest`): + The request object. Request for the `UpdateRegistration` + method. + registration (:class:`google.cloud.domains_v1.types.Registration`): + Fields of the ``Registration`` to update. + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the labels are being updated, the ``update_mask`` is + ``"labels"``. + + 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, 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 = domains.UpdateRegistrationRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + 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_registration, + 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( + (("registration.name", request.registration.name),) + ), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def configure_management_settings( + self, + request: domains.ConfigureManagementSettingsRequest = None, + *, + registration: str = None, + management_settings: domains.ManagementSettings = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Updates a ``Registration``'s management settings. + + Args: + request (:class:`google.cloud.domains_v1.types.ConfigureManagementSettingsRequest`): + The request object. Request for the + `ConfigureManagementSettings` method. + registration (:class:`str`): + Required. The name of the ``Registration`` whose + management settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + management_settings (:class:`google.cloud.domains_v1.types.ManagementSettings`): + Fields of the ``ManagementSettings`` to update. + This corresponds to the ``management_settings`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the transfer lock is being updated, the ``update_mask`` + is ``"transfer_lock_state"``. + + 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, management_settings, 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 = domains.ConfigureManagementSettingsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + if management_settings is not None: + request.management_settings = management_settings + 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.configure_management_settings, + 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( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def configure_dns_settings( + self, + request: domains.ConfigureDnsSettingsRequest = None, + *, + registration: str = None, + dns_settings: domains.DnsSettings = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Updates a ``Registration``'s DNS settings. + + Args: + request (:class:`google.cloud.domains_v1.types.ConfigureDnsSettingsRequest`): + The request object. Request for the + `ConfigureDnsSettings` method. + registration (:class:`str`): + Required. The name of the ``Registration`` whose DNS + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + dns_settings (:class:`google.cloud.domains_v1.types.DnsSettings`): + Fields of the ``DnsSettings`` to update. + This corresponds to the ``dns_settings`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the name servers are being updated for an existing + Custom DNS configuration, the ``update_mask`` is + ``"custom_dns.name_servers"``. + + When changing the DNS provider from one type to another, + pass the new provider's field name as part of the field + mask. For example, when changing from a Google Domains + DNS configuration to a Custom DNS configuration, the + ``update_mask`` is ``"custom_dns"``. // + + 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, dns_settings, 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 = domains.ConfigureDnsSettingsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + if dns_settings is not None: + request.dns_settings = dns_settings + 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.configure_dns_settings, + 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( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def configure_contact_settings( + self, + request: domains.ConfigureContactSettingsRequest = None, + *, + registration: str = None, + contact_settings: domains.ContactSettings = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Updates a ``Registration``'s contact settings. Some changes + require confirmation by the domain's registrant contact . + + Args: + request (:class:`google.cloud.domains_v1.types.ConfigureContactSettingsRequest`): + The request object. Request for the + `ConfigureContactSettings` method. + registration (:class:`str`): + Required. The name of the ``Registration`` whose contact + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + contact_settings (:class:`google.cloud.domains_v1.types.ContactSettings`): + Fields of the ``ContactSettings`` to update. + This corresponds to the ``contact_settings`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the registrant contact is being updated, the + ``update_mask`` is ``"registrant_contact"``. + + 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, contact_settings, 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 = domains.ConfigureContactSettingsRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + if contact_settings is not None: + request.contact_settings = contact_settings + 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.configure_contact_settings, + 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( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def export_registration( + self, + request: domains.ExportRegistrationRequest = None, + *, + name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. + + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Args: + request (:class:`google.cloud.domains_v1.types.ExportRegistrationRequest`): + The request object. Request for the `ExportRegistration` + method. + name (:class:`str`): + Required. The name of the ``Registration`` to export, in + the format ``projects/*/locations/*/registrations/*``. + + 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity 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 = domains.ExportRegistrationRequest(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.export_registration, + 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,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def delete_registration( + self, + request: domains.DeleteRegistrationRequest = None, + *, + name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Deletes a ``Registration`` resource. + + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: + + - ``state`` is ``EXPORTED`` with ``expire_time`` in the past + - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Args: + request (:class:`google.cloud.domains_v1.types.DeleteRegistrationRequest`): + The request object. Request for the `DeleteRegistration` + method. + name (:class:`str`): + Required. The name of the ``Registration`` to delete, in + the format ``projects/*/locations/*/registrations/*``. + + 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated + empty messages in your APIs. A typical example is to + use it as the request or the response type of an API + method. For instance: + + service Foo { + rpc Bar(google.protobuf.Empty) returns + (google.protobuf.Empty); + + } + + The JSON representation for Empty is empty JSON + object {}. + + """ + # Create or coerce a protobuf request object. + # Sanity 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 = domains.DeleteRegistrationRequest(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.delete_registration, + 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,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + empty_pb2.Empty, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + async def retrieve_authorization_code( + self, + request: domains.RetrieveAuthorizationCodeRequest = None, + *, + registration: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.AuthorizationCode: + r"""Gets the authorization code of the ``Registration`` for the + purpose of transferring the domain to another registrar. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Args: + request (:class:`google.cloud.domains_v1.types.RetrieveAuthorizationCodeRequest`): + The request object. Request for the + `RetrieveAuthorizationCode` method. + registration (:class:`str`): + Required. The name of the ``Registration`` whose + authorization code is being retrieved, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` 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.domains_v1.types.AuthorizationCode: + Defines an authorization code. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration]) + 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 = domains.RetrieveAuthorizationCodeRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.retrieve_authorization_code, + 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( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + async def reset_authorization_code( + self, + request: domains.ResetAuthorizationCodeRequest = None, + *, + registration: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.AuthorizationCode: + r"""Resets the authorization code of the ``Registration`` to a new + random string. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Args: + request (:class:`google.cloud.domains_v1.types.ResetAuthorizationCodeRequest`): + The request object. Request for the + `ResetAuthorizationCode` method. + registration (:class:`str`): + Required. The name of the ``Registration`` whose + authorization code is being reset, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` 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.domains_v1.types.AuthorizationCode: + Defines an authorization code. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration]) + 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 = domains.ResetAuthorizationCodeRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.reset_authorization_code, + 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( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc, tb): + await self.transport.close() + + +try: + DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=pkg_resources.get_distribution("google-cloud-domains",).version, + ) +except pkg_resources.DistributionNotFound: + DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo() + + +__all__ = ("DomainsAsyncClient",) diff --git a/google/cloud/domains_v1/services/domains/client.py b/google/cloud/domains_v1/services/domains/client.py new file mode 100644 index 0000000..6774df5 --- /dev/null +++ b/google/cloud/domains_v1/services/domains/client.py @@ -0,0 +1,1988 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +from distutils import util +import os +import re +from typing import Dict, Optional, Sequence, Tuple, Type, Union +import pkg_resources + +from google.api_core import client_options as client_options_lib # type: ignore +from google.api_core import exceptions as core_exceptions # type: ignore +from google.api_core import gapic_v1 # type: ignore +from google.api_core import retry as retries # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport import mtls # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.auth.exceptions import MutualTLSChannelError # type: ignore +from google.oauth2 import service_account # type: ignore + +from google.api_core import operation # type: ignore +from google.api_core import operation_async # type: ignore +from google.cloud.domains_v1.services.domains import pagers +from google.cloud.domains_v1.types import domains +from google.protobuf import empty_pb2 # type: ignore +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore +from google.type import money_pb2 # type: ignore +from .transports.base import DomainsTransport, DEFAULT_CLIENT_INFO +from .transports.grpc import DomainsGrpcTransport +from .transports.grpc_asyncio import DomainsGrpcAsyncIOTransport + + +class DomainsClientMeta(type): + """Metaclass for the Domains client. + + This provides class-level methods for building and retrieving + support objects (e.g. transport) without polluting the client instance + objects. + """ + + _transport_registry = OrderedDict() # type: Dict[str, Type[DomainsTransport]] + _transport_registry["grpc"] = DomainsGrpcTransport + _transport_registry["grpc_asyncio"] = DomainsGrpcAsyncIOTransport + + def get_transport_class(cls, label: str = None,) -> Type[DomainsTransport]: + """Returns an appropriate transport class. + + Args: + label: The name of the desired transport. If none is + provided, then the first transport in the registry is used. + + Returns: + The transport class to use. + """ + # If a specific transport is requested, return that one. + if label: + return cls._transport_registry[label] + + # No transport is requested; return the default (that is, the first one + # in the dictionary). + return next(iter(cls._transport_registry.values())) + + +class DomainsClient(metaclass=DomainsClientMeta): + """The Cloud Domains API enables management and configuration of + domain names. + """ + + @staticmethod + def _get_default_mtls_endpoint(api_endpoint): + """Converts api endpoint to mTLS endpoint. + + Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to + "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively. + Args: + api_endpoint (Optional[str]): the api endpoint to convert. + Returns: + str: converted mTLS api endpoint. + """ + if not api_endpoint: + return api_endpoint + + mtls_endpoint_re = re.compile( + r"(?P[^.]+)(?P\.mtls)?(?P\.sandbox)?(?P\.googleapis\.com)?" + ) + + m = mtls_endpoint_re.match(api_endpoint) + name, mtls, sandbox, googledomain = m.groups() + if mtls or not googledomain: + return api_endpoint + + if sandbox: + return api_endpoint.replace( + "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" + ) + + return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") + + DEFAULT_ENDPOINT = "domains.googleapis.com" + DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore + DEFAULT_ENDPOINT + ) + + @classmethod + def from_service_account_info(cls, info: dict, *args, **kwargs): + """Creates an instance of this client using the provided credentials + info. + + Args: + info (dict): The service account private key info. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + DomainsClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_info(info) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + @classmethod + def from_service_account_file(cls, filename: str, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + DomainsClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_file(filename) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + from_service_account_json = from_service_account_file + + @property + def transport(self) -> DomainsTransport: + """Returns the transport used by the client instance. + + Returns: + DomainsTransport: The transport used by the client + instance. + """ + return self._transport + + @staticmethod + def registration_path(project: str, location: str, registration: str,) -> str: + """Returns a fully-qualified registration string.""" + return "projects/{project}/locations/{location}/registrations/{registration}".format( + project=project, location=location, registration=registration, + ) + + @staticmethod + def parse_registration_path(path: str) -> Dict[str, str]: + """Parses a registration path into its component segments.""" + m = re.match( + r"^projects/(?P.+?)/locations/(?P.+?)/registrations/(?P.+?)$", + path, + ) + return m.groupdict() if m else {} + + @staticmethod + def common_billing_account_path(billing_account: str,) -> str: + """Returns a fully-qualified billing_account string.""" + return "billingAccounts/{billing_account}".format( + billing_account=billing_account, + ) + + @staticmethod + def parse_common_billing_account_path(path: str) -> Dict[str, str]: + """Parse a billing_account path into its component segments.""" + m = re.match(r"^billingAccounts/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_folder_path(folder: str,) -> str: + """Returns a fully-qualified folder string.""" + return "folders/{folder}".format(folder=folder,) + + @staticmethod + def parse_common_folder_path(path: str) -> Dict[str, str]: + """Parse a folder path into its component segments.""" + m = re.match(r"^folders/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_organization_path(organization: str,) -> str: + """Returns a fully-qualified organization string.""" + return "organizations/{organization}".format(organization=organization,) + + @staticmethod + def parse_common_organization_path(path: str) -> Dict[str, str]: + """Parse a organization path into its component segments.""" + m = re.match(r"^organizations/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_project_path(project: str,) -> str: + """Returns a fully-qualified project string.""" + return "projects/{project}".format(project=project,) + + @staticmethod + def parse_common_project_path(path: str) -> Dict[str, str]: + """Parse a project path into its component segments.""" + m = re.match(r"^projects/(?P.+?)$", path) + return m.groupdict() if m else {} + + @staticmethod + def common_location_path(project: str, location: str,) -> str: + """Returns a fully-qualified location string.""" + return "projects/{project}/locations/{location}".format( + project=project, location=location, + ) + + @staticmethod + def parse_common_location_path(path: str) -> Dict[str, str]: + """Parse a location path into its component segments.""" + m = re.match(r"^projects/(?P.+?)/locations/(?P.+?)$", path) + return m.groupdict() if m else {} + + def __init__( + self, + *, + credentials: Optional[ga_credentials.Credentials] = None, + transport: Union[str, DomainsTransport, None] = None, + client_options: Optional[client_options_lib.ClientOptions] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + ) -> None: + """Instantiates the domains client. + + Args: + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + transport (Union[str, DomainsTransport]): The + transport to use. If set to None, a transport is chosen + automatically. + client_options (google.api_core.client_options.ClientOptions): Custom options for the + client. It won't take effect if a ``transport`` instance is provided. + (1) The ``api_endpoint`` property can be used to override the + default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT + environment variable can also be used to override the endpoint: + "always" (always use the default mTLS endpoint), "never" (always + use the default regular endpoint) and "auto" (auto switch to the + default mTLS endpoint if client certificate is present, this is + the default value). However, the ``api_endpoint`` property takes + precedence if provided. + (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable + is "true", then the ``client_cert_source`` property can be used + to provide client certificate for mutual TLS transport. If + not provided, the default SSL client certificate will be used if + present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not + set, no client certificate will be used. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport + creation failed for any reason. + """ + if isinstance(client_options, dict): + client_options = client_options_lib.from_dict(client_options) + if client_options is None: + client_options = client_options_lib.ClientOptions() + + # Create SSL credentials for mutual TLS if needed. + use_client_cert = bool( + util.strtobool(os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false")) + ) + + client_cert_source_func = None + is_mtls = False + if use_client_cert: + if client_options.client_cert_source: + is_mtls = True + client_cert_source_func = client_options.client_cert_source + else: + is_mtls = mtls.has_default_client_cert_source() + if is_mtls: + client_cert_source_func = mtls.default_client_cert_source() + else: + client_cert_source_func = None + + # Figure out which api endpoint to use. + if client_options.api_endpoint is not None: + api_endpoint = client_options.api_endpoint + else: + use_mtls_env = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto") + if use_mtls_env == "never": + api_endpoint = self.DEFAULT_ENDPOINT + elif use_mtls_env == "always": + api_endpoint = self.DEFAULT_MTLS_ENDPOINT + elif use_mtls_env == "auto": + if is_mtls: + api_endpoint = self.DEFAULT_MTLS_ENDPOINT + else: + api_endpoint = self.DEFAULT_ENDPOINT + else: + raise MutualTLSChannelError( + "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted " + "values: never, auto, always" + ) + + # Save or instantiate the transport. + # Ordinarily, we provide the transport, but allowing a custom transport + # instance provides an extensibility point for unusual situations. + if isinstance(transport, DomainsTransport): + # transport is a DomainsTransport instance. + if credentials or client_options.credentials_file: + raise ValueError( + "When providing a transport instance, " + "provide its credentials directly." + ) + if client_options.scopes: + raise ValueError( + "When providing a transport instance, provide its scopes " + "directly." + ) + self._transport = transport + else: + Transport = type(self).get_transport_class(transport) + self._transport = Transport( + credentials=credentials, + credentials_file=client_options.credentials_file, + host=api_endpoint, + scopes=client_options.scopes, + client_cert_source_for_mtls=client_cert_source_func, + quota_project_id=client_options.quota_project_id, + client_info=client_info, + always_use_jwt_access=True, + ) + + def search_domains( + self, + request: Union[domains.SearchDomainsRequest, dict] = None, + *, + location: str = None, + query: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.SearchDomainsResponse: + r"""Searches for available domain names similar to the provided + query. + + Availability results from this method are approximate; call + ``RetrieveRegisterParameters`` on a domain before registering to + confirm availability. + + Args: + request (Union[google.cloud.domains_v1.types.SearchDomainsRequest, dict]): + The request object. Request for the `SearchDomains` + method. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + query (str): + Required. String used to search for + available domain names. + + This corresponds to the ``query`` 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.domains_v1.types.SearchDomainsResponse: + Response for the SearchDomains method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, query]) + 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 domains.SearchDomainsRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.SearchDomainsRequest): + request = domains.SearchDomainsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if query is not None: + request.query = query + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.search_domains] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + def retrieve_register_parameters( + self, + request: Union[domains.RetrieveRegisterParametersRequest, dict] = None, + *, + location: str = None, + domain_name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.RetrieveRegisterParametersResponse: + r"""Gets parameters needed to register a new domain name, including + price and up-to-date availability. Use the returned values to + call ``RegisterDomain``. + + Args: + request (Union[google.cloud.domains_v1.types.RetrieveRegisterParametersRequest, dict]): + The request object. Request for the + `RetrieveRegisterParameters` method. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + domain_name (str): + Required. The domain name. Unicode + domain names must be expressed in + Punycode format. + + This corresponds to the ``domain_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.domains_v1.types.RetrieveRegisterParametersResponse: + Response for the RetrieveRegisterParameters method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, domain_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 domains.RetrieveRegisterParametersRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.RetrieveRegisterParametersRequest): + request = domains.RetrieveRegisterParametersRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if domain_name is not None: + request.domain_name = domain_name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.retrieve_register_parameters + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + def register_domain( + self, + request: Union[domains.RegisterDomainRequest, dict] = None, + *, + parent: str = None, + registration: domains.Registration = None, + yearly_price: money_pb2.Money = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Registers a new domain name and creates a corresponding + ``Registration`` resource. + + Call ``RetrieveRegisterParameters`` first to check availability + of the domain name and determine parameters like price that are + needed to build a call to this method. + + A successful call creates a ``Registration`` resource in state + ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within + 1-2 minutes, indicating that the domain was successfully + registered. If the resource ends up in state + ``REGISTRATION_FAILED``, it indicates that the domain was not + registered successfully, and you can safely delete the resource + and retry registration. + + Args: + request (Union[google.cloud.domains_v1.types.RegisterDomainRequest, dict]): + The request object. Request for the `RegisterDomain` + method. + parent (str): + Required. The parent resource of the ``Registration``. + Must be in the format ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + registration (google.cloud.domains_v1.types.Registration): + Required. The complete ``Registration`` resource to be + created. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + yearly_price (google.type.money_pb2.Money): + Required. Yearly price to register or + renew the domain. The value that should + be put here can be obtained from + RetrieveRegisterParameters or + SearchDomains calls. + + This corresponds to the ``yearly_price`` 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([parent, registration, yearly_price]) + 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 domains.RegisterDomainRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.RegisterDomainRequest): + request = domains.RegisterDomainRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if registration is not None: + request.registration = registration + if yearly_price is not None: + request.yearly_price = yearly_price + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.register_domain] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def retrieve_transfer_parameters( + self, + request: Union[domains.RetrieveTransferParametersRequest, dict] = None, + *, + location: str = None, + domain_name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.RetrieveTransferParametersResponse: + r"""Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Args: + request (Union[google.cloud.domains_v1.types.RetrieveTransferParametersRequest, dict]): + The request object. Request for the + `RetrieveTransferParameters` method. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + domain_name (str): + Required. The domain name. Unicode + domain names must be expressed in + Punycode format. + + This corresponds to the ``domain_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.domains_v1.types.RetrieveTransferParametersResponse: + Response for the RetrieveTransferParameters method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, domain_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 domains.RetrieveTransferParametersRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.RetrieveTransferParametersRequest): + request = domains.RetrieveTransferParametersRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if domain_name is not None: + request.domain_name = domain_name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.retrieve_transfer_parameters + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + def transfer_domain( + self, + request: Union[domains.TransferDomainRequest, dict] = None, + *, + parent: str = None, + registration: domains.Registration = None, + yearly_price: money_pb2.Money = None, + authorization_code: domains.AuthorizationCode = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Args: + request (Union[google.cloud.domains_v1.types.TransferDomainRequest, dict]): + The request object. Request for the `TransferDomain` + method. + parent (str): + Required. The parent resource of the ``Registration``. + Must be in the format ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + registration (google.cloud.domains_v1.types.Registration): + Required. The complete ``Registration`` resource to be + created. + + You can leave ``registration.dns_settings`` unset to + import the domain's current DNS configuration from its + current registrar. Use this option only if you are sure + that the domain's current DNS service does not cease + upon transfer, as is often the case for DNS services + provided for free by the registrar. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + yearly_price (google.type.money_pb2.Money): + Required. Acknowledgement of the price to transfer or + renew the domain for one year. Call + ``RetrieveTransferParameters`` to obtain the price, + which you must acknowledge. + + This corresponds to the ``yearly_price`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + authorization_code (google.cloud.domains_v1.types.AuthorizationCode): + The domain's transfer authorization + code. You can obtain this from the + domain's current registrar. + + This corresponds to the ``authorization_code`` 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any( + [parent, registration, yearly_price, authorization_code] + ) + 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 domains.TransferDomainRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.TransferDomainRequest): + request = domains.TransferDomainRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if registration is not None: + request.registration = registration + if yearly_price is not None: + request.yearly_price = yearly_price + if authorization_code is not None: + request.authorization_code = authorization_code + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.transfer_domain] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def list_registrations( + self, + request: Union[domains.ListRegistrationsRequest, dict] = None, + *, + parent: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> pagers.ListRegistrationsPager: + r"""Lists the ``Registration`` resources in a project. + + Args: + request (Union[google.cloud.domains_v1.types.ListRegistrationsRequest, dict]): + The request object. Request for the `ListRegistrations` + method. + parent (str): + Required. The project and location from which to list + ``Registration``\ s, specified in the format + ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + google.cloud.domains_v1.services.domains.pagers.ListRegistrationsPager: + Response for the ListRegistrations method. + + Iterating over this object will yield results and + resolve additional pages automatically. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([parent]) + 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 domains.ListRegistrationsRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.ListRegistrationsRequest): + request = domains.ListRegistrationsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.list_registrations] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # This method is paged; wrap the response in a pager, which provides + # an `__iter__` convenience method. + response = pagers.ListRegistrationsPager( + method=rpc, request=request, response=response, metadata=metadata, + ) + + # Done; return the response. + return response + + def get_registration( + self, + request: Union[domains.GetRegistrationRequest, dict] = None, + *, + name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.Registration: + r"""Gets the details of a ``Registration`` resource. + + Args: + request (Union[google.cloud.domains_v1.types.GetRegistrationRequest, dict]): + The request object. Request for the `GetRegistration` + method. + name (str): + Required. The name of the ``Registration`` to get, in + the format ``projects/*/locations/*/registrations/*``. + + 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.domains_v1.types.Registration: + The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity 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 domains.GetRegistrationRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.GetRegistrationRequest): + request = domains.GetRegistrationRequest(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_registration] + + # 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_registration( + self, + request: Union[domains.UpdateRegistrationRequest, dict] = None, + *, + registration: domains.Registration = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Updates select fields of a ``Registration`` resource, notably + ``labels``. To update other fields, use the appropriate custom + update method: + + - To update management settings, see + ``ConfigureManagementSettings`` + - To update DNS configuration, see ``ConfigureDnsSettings`` + - To update contact information, see + ``ConfigureContactSettings`` + + Args: + request (Union[google.cloud.domains_v1.types.UpdateRegistrationRequest, dict]): + The request object. Request for the `UpdateRegistration` + method. + registration (google.cloud.domains_v1.types.Registration): + Fields of the ``Registration`` to update. + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the labels are being updated, the ``update_mask`` is + ``"labels"``. + + 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, 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 domains.UpdateRegistrationRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.UpdateRegistrationRequest): + request = domains.UpdateRegistrationRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + 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_registration] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("registration.name", request.registration.name),) + ), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def configure_management_settings( + self, + request: Union[domains.ConfigureManagementSettingsRequest, dict] = None, + *, + registration: str = None, + management_settings: domains.ManagementSettings = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Updates a ``Registration``'s management settings. + + Args: + request (Union[google.cloud.domains_v1.types.ConfigureManagementSettingsRequest, dict]): + The request object. Request for the + `ConfigureManagementSettings` method. + registration (str): + Required. The name of the ``Registration`` whose + management settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + management_settings (google.cloud.domains_v1.types.ManagementSettings): + Fields of the ``ManagementSettings`` to update. + This corresponds to the ``management_settings`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the transfer lock is being updated, the ``update_mask`` + is ``"transfer_lock_state"``. + + 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, management_settings, 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 domains.ConfigureManagementSettingsRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.ConfigureManagementSettingsRequest): + request = domains.ConfigureManagementSettingsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + if management_settings is not None: + request.management_settings = management_settings + 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.configure_management_settings + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def configure_dns_settings( + self, + request: Union[domains.ConfigureDnsSettingsRequest, dict] = None, + *, + registration: str = None, + dns_settings: domains.DnsSettings = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Updates a ``Registration``'s DNS settings. + + Args: + request (Union[google.cloud.domains_v1.types.ConfigureDnsSettingsRequest, dict]): + The request object. Request for the + `ConfigureDnsSettings` method. + registration (str): + Required. The name of the ``Registration`` whose DNS + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + dns_settings (google.cloud.domains_v1.types.DnsSettings): + Fields of the ``DnsSettings`` to update. + This corresponds to the ``dns_settings`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the name servers are being updated for an existing + Custom DNS configuration, the ``update_mask`` is + ``"custom_dns.name_servers"``. + + When changing the DNS provider from one type to another, + pass the new provider's field name as part of the field + mask. For example, when changing from a Google Domains + DNS configuration to a Custom DNS configuration, the + ``update_mask`` is ``"custom_dns"``. // + + 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, dns_settings, 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 domains.ConfigureDnsSettingsRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.ConfigureDnsSettingsRequest): + request = domains.ConfigureDnsSettingsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + if dns_settings is not None: + request.dns_settings = dns_settings + 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.configure_dns_settings] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def configure_contact_settings( + self, + request: Union[domains.ConfigureContactSettingsRequest, dict] = None, + *, + registration: str = None, + contact_settings: domains.ContactSettings = None, + update_mask: field_mask_pb2.FieldMask = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Updates a ``Registration``'s contact settings. Some changes + require confirmation by the domain's registrant contact . + + Args: + request (Union[google.cloud.domains_v1.types.ConfigureContactSettingsRequest, dict]): + The request object. Request for the + `ConfigureContactSettings` method. + registration (str): + Required. The name of the ``Registration`` whose contact + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + contact_settings (google.cloud.domains_v1.types.ContactSettings): + Fields of the ``ContactSettings`` to update. + This corresponds to the ``contact_settings`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to + update as a comma-separated list. For example, if only + the registrant contact is being updated, the + ``update_mask`` is ``"registrant_contact"``. + + 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration, contact_settings, 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 domains.ConfigureContactSettingsRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.ConfigureContactSettingsRequest): + request = domains.ConfigureContactSettingsRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + if contact_settings is not None: + request.contact_settings = contact_settings + 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.configure_contact_settings + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def export_registration( + self, + request: Union[domains.ExportRegistrationRequest, dict] = None, + *, + name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. + + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Args: + request (Union[google.cloud.domains_v1.types.ExportRegistrationRequest, dict]): + The request object. Request for the `ExportRegistration` + method. + name (str): + Required. The name of the ``Registration`` to export, in + the format ``projects/*/locations/*/registrations/*``. + + 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity 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 domains.ExportRegistrationRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.ExportRegistrationRequest): + request = domains.ExportRegistrationRequest(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.export_registration] + + # 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,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def delete_registration( + self, + request: Union[domains.DeleteRegistrationRequest, dict] = None, + *, + name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Deletes a ``Registration`` resource. + + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: + + - ``state`` is ``EXPORTED`` with ``expire_time`` in the past + - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Args: + request (Union[google.cloud.domains_v1.types.DeleteRegistrationRequest, dict]): + The request object. Request for the `DeleteRegistration` + method. + name (str): + Required. The name of the ``Registration`` to delete, in + the format ``projects/*/locations/*/registrations/*``. + + 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated + empty messages in your APIs. A typical example is to + use it as the request or the response type of an API + method. For instance: + + service Foo { + rpc Bar(google.protobuf.Empty) returns + (google.protobuf.Empty); + + } + + The JSON representation for Empty is empty JSON + object {}. + + """ + # Create or coerce a protobuf request object. + # Sanity 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 domains.DeleteRegistrationRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.DeleteRegistrationRequest): + request = domains.DeleteRegistrationRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.delete_registration] + + # 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,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + empty_pb2.Empty, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + + def retrieve_authorization_code( + self, + request: Union[domains.RetrieveAuthorizationCodeRequest, dict] = None, + *, + registration: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.AuthorizationCode: + r"""Gets the authorization code of the ``Registration`` for the + purpose of transferring the domain to another registrar. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Args: + request (Union[google.cloud.domains_v1.types.RetrieveAuthorizationCodeRequest, dict]): + The request object. Request for the + `RetrieveAuthorizationCode` method. + registration (str): + Required. The name of the ``Registration`` whose + authorization code is being retrieved, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` 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.domains_v1.types.AuthorizationCode: + Defines an authorization code. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration]) + 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 domains.RetrieveAuthorizationCodeRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.RetrieveAuthorizationCodeRequest): + request = domains.RetrieveAuthorizationCodeRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.retrieve_authorization_code + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + def reset_authorization_code( + self, + request: Union[domains.ResetAuthorizationCodeRequest, dict] = None, + *, + registration: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.AuthorizationCode: + r"""Resets the authorization code of the ``Registration`` to a new + random string. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Args: + request (Union[google.cloud.domains_v1.types.ResetAuthorizationCodeRequest, dict]): + The request object. Request for the + `ResetAuthorizationCode` method. + registration (str): + Required. The name of the ``Registration`` whose + authorization code is being reset, in the format + ``projects/*/locations/*/registrations/*``. + + This corresponds to the ``registration`` 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.domains_v1.types.AuthorizationCode: + Defines an authorization code. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([registration]) + 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 domains.ResetAuthorizationCodeRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.ResetAuthorizationCodeRequest): + request = domains.ResetAuthorizationCodeRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if registration is not None: + request.registration = registration + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.reset_authorization_code] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("registration", request.registration),) + ), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + def __enter__(self): + return self + + def __exit__(self, type, value, traceback): + """Releases underlying transport's resources. + + .. warning:: + ONLY use as a context manager if the transport is NOT shared + with other clients! Exiting the with block will CLOSE the transport + and may cause errors in other clients! + """ + self.transport.close() + + +try: + DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=pkg_resources.get_distribution("google-cloud-domains",).version, + ) +except pkg_resources.DistributionNotFound: + DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo() + + +__all__ = ("DomainsClient",) diff --git a/google/cloud/domains_v1/services/domains/pagers.py b/google/cloud/domains_v1/services/domains/pagers.py new file mode 100644 index 0000000..2e777ff --- /dev/null +++ b/google/cloud/domains_v1/services/domains/pagers.py @@ -0,0 +1,155 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from typing import ( + Any, + AsyncIterator, + Awaitable, + Callable, + Sequence, + Tuple, + Optional, + Iterator, +) + +from google.cloud.domains_v1.types import domains + + +class ListRegistrationsPager: + """A pager for iterating through ``list_registrations`` requests. + + This class thinly wraps an initial + :class:`google.cloud.domains_v1.types.ListRegistrationsResponse` object, and + provides an ``__iter__`` method to iterate through its + ``registrations`` field. + + If there are more pages, the ``__iter__`` method will make additional + ``ListRegistrations`` requests and continue to iterate + through the ``registrations`` field on the + corresponding responses. + + All the usual :class:`google.cloud.domains_v1.types.ListRegistrationsResponse` + attributes are available on the pager. If multiple requests are made, only + the most recent response is retained, and thus used for attribute lookup. + """ + + def __init__( + self, + method: Callable[..., domains.ListRegistrationsResponse], + request: domains.ListRegistrationsRequest, + response: domains.ListRegistrationsResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiate the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.domains_v1.types.ListRegistrationsRequest): + The initial request object. + response (google.cloud.domains_v1.types.ListRegistrationsResponse): + The initial response object. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + """ + self._method = method + self._request = domains.ListRegistrationsRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + def pages(self) -> Iterator[domains.ListRegistrationsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = self._method(self._request, metadata=self._metadata) + yield self._response + + def __iter__(self) -> Iterator[domains.Registration]: + for page in self.pages: + yield from page.registrations + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) + + +class ListRegistrationsAsyncPager: + """A pager for iterating through ``list_registrations`` requests. + + This class thinly wraps an initial + :class:`google.cloud.domains_v1.types.ListRegistrationsResponse` object, and + provides an ``__aiter__`` method to iterate through its + ``registrations`` field. + + If there are more pages, the ``__aiter__`` method will make additional + ``ListRegistrations`` requests and continue to iterate + through the ``registrations`` field on the + corresponding responses. + + All the usual :class:`google.cloud.domains_v1.types.ListRegistrationsResponse` + attributes are available on the pager. If multiple requests are made, only + the most recent response is retained, and thus used for attribute lookup. + """ + + def __init__( + self, + method: Callable[..., Awaitable[domains.ListRegistrationsResponse]], + request: domains.ListRegistrationsRequest, + response: domains.ListRegistrationsResponse, + *, + metadata: Sequence[Tuple[str, str]] = () + ): + """Instantiates the pager. + + Args: + method (Callable): The method that was originally called, and + which instantiated this pager. + request (google.cloud.domains_v1.types.ListRegistrationsRequest): + The initial request object. + response (google.cloud.domains_v1.types.ListRegistrationsResponse): + The initial response object. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + """ + self._method = method + self._request = domains.ListRegistrationsRequest(request) + self._response = response + self._metadata = metadata + + def __getattr__(self, name: str) -> Any: + return getattr(self._response, name) + + @property + async def pages(self) -> AsyncIterator[domains.ListRegistrationsResponse]: + yield self._response + while self._response.next_page_token: + self._request.page_token = self._response.next_page_token + self._response = await self._method(self._request, metadata=self._metadata) + yield self._response + + def __aiter__(self) -> AsyncIterator[domains.Registration]: + async def async_generator(): + async for page in self.pages: + for response in page.registrations: + yield response + + return async_generator() + + def __repr__(self) -> str: + return "{0}<{1!r}>".format(self.__class__.__name__, self._response) diff --git a/google/cloud/domains_v1/services/domains/transports/__init__.py b/google/cloud/domains_v1/services/domains/transports/__init__.py new file mode 100644 index 0000000..d1eb105 --- /dev/null +++ b/google/cloud/domains_v1/services/domains/transports/__init__.py @@ -0,0 +1,33 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from collections import OrderedDict +from typing import Dict, Type + +from .base import DomainsTransport +from .grpc import DomainsGrpcTransport +from .grpc_asyncio import DomainsGrpcAsyncIOTransport + + +# Compile a registry of transports. +_transport_registry = OrderedDict() # type: Dict[str, Type[DomainsTransport]] +_transport_registry["grpc"] = DomainsGrpcTransport +_transport_registry["grpc_asyncio"] = DomainsGrpcAsyncIOTransport + +__all__ = ( + "DomainsTransport", + "DomainsGrpcTransport", + "DomainsGrpcAsyncIOTransport", +) diff --git a/google/cloud/domains_v1/services/domains/transports/base.py b/google/cloud/domains_v1/services/domains/transports/base.py new file mode 100644 index 0000000..522654d --- /dev/null +++ b/google/cloud/domains_v1/services/domains/transports/base.py @@ -0,0 +1,377 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +import abc +from typing import Awaitable, Callable, Dict, Optional, Sequence, Union +import packaging.version +import pkg_resources + +import google.auth # type: ignore +import google.api_core # type: ignore +from google.api_core import exceptions as core_exceptions # type: ignore +from google.api_core import gapic_v1 # type: ignore +from google.api_core import retry as retries # type: ignore +from google.api_core import operations_v1 # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.oauth2 import service_account # type: ignore + +from google.cloud.domains_v1.types import domains +from google.longrunning import operations_pb2 # type: ignore + +try: + DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=pkg_resources.get_distribution("google-cloud-domains",).version, + ) +except pkg_resources.DistributionNotFound: + DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo() + +try: + # google.auth.__version__ was added in 1.26.0 + _GOOGLE_AUTH_VERSION = google.auth.__version__ +except AttributeError: + try: # try pkg_resources if it is available + _GOOGLE_AUTH_VERSION = pkg_resources.get_distribution("google-auth").version + except pkg_resources.DistributionNotFound: # pragma: NO COVER + _GOOGLE_AUTH_VERSION = None + + +class DomainsTransport(abc.ABC): + """Abstract transport class for Domains.""" + + AUTH_SCOPES = ("https://www.googleapis.com/auth/cloud-platform",) + + DEFAULT_HOST: str = "domains.googleapis.com" + + def __init__( + self, + *, + host: str = DEFAULT_HOST, + credentials: ga_credentials.Credentials = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + **kwargs, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to. + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + credentials_file (Optional[str]): A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is mutually exclusive with credentials. + scopes (Optional[Sequence[str]]): A list of scopes. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + """ + # Save the hostname. Default to port 443 (HTTPS) if none is specified. + if ":" not in host: + host += ":443" + self._host = host + + scopes_kwargs = self._get_scopes_kwargs(self._host, scopes) + + # Save the scopes. + self._scopes = scopes + + # If no credentials are provided, then determine the appropriate + # defaults. + if credentials and credentials_file: + raise core_exceptions.DuplicateCredentialArgs( + "'credentials_file' and 'credentials' are mutually exclusive" + ) + + if credentials_file is not None: + credentials, _ = google.auth.load_credentials_from_file( + credentials_file, **scopes_kwargs, quota_project_id=quota_project_id + ) + + elif credentials is None: + credentials, _ = google.auth.default( + **scopes_kwargs, quota_project_id=quota_project_id + ) + + # If the credentials are service account credentials, then always try to use self signed JWT. + if ( + always_use_jwt_access + and isinstance(credentials, service_account.Credentials) + and hasattr(service_account.Credentials, "with_always_use_jwt_access") + ): + credentials = credentials.with_always_use_jwt_access(True) + + # Save the credentials. + self._credentials = credentials + + # TODO(busunkim): This method is in the base transport + # to avoid duplicating code across the transport classes. These functions + # should be deleted once the minimum required versions of google-auth is increased. + + # TODO: Remove this function once google-auth >= 1.25.0 is required + @classmethod + def _get_scopes_kwargs( + cls, host: str, scopes: Optional[Sequence[str]] + ) -> Dict[str, Optional[Sequence[str]]]: + """Returns scopes kwargs to pass to google-auth methods depending on the google-auth version""" + + scopes_kwargs = {} + + if _GOOGLE_AUTH_VERSION and ( + packaging.version.parse(_GOOGLE_AUTH_VERSION) + >= packaging.version.parse("1.25.0") + ): + scopes_kwargs = {"scopes": scopes, "default_scopes": cls.AUTH_SCOPES} + else: + scopes_kwargs = {"scopes": scopes or cls.AUTH_SCOPES} + + return scopes_kwargs + + def _prep_wrapped_messages(self, client_info): + # Precompute the wrapped methods. + self._wrapped_methods = { + self.search_domains: gapic_v1.method.wrap_method( + self.search_domains, default_timeout=None, client_info=client_info, + ), + self.retrieve_register_parameters: gapic_v1.method.wrap_method( + self.retrieve_register_parameters, + default_timeout=None, + client_info=client_info, + ), + self.register_domain: gapic_v1.method.wrap_method( + self.register_domain, default_timeout=None, client_info=client_info, + ), + self.retrieve_transfer_parameters: gapic_v1.method.wrap_method( + self.retrieve_transfer_parameters, + default_timeout=None, + client_info=client_info, + ), + self.transfer_domain: gapic_v1.method.wrap_method( + self.transfer_domain, default_timeout=None, client_info=client_info, + ), + self.list_registrations: gapic_v1.method.wrap_method( + self.list_registrations, default_timeout=None, client_info=client_info, + ), + self.get_registration: gapic_v1.method.wrap_method( + self.get_registration, default_timeout=None, client_info=client_info, + ), + self.update_registration: gapic_v1.method.wrap_method( + self.update_registration, default_timeout=None, client_info=client_info, + ), + self.configure_management_settings: gapic_v1.method.wrap_method( + self.configure_management_settings, + default_timeout=None, + client_info=client_info, + ), + self.configure_dns_settings: gapic_v1.method.wrap_method( + self.configure_dns_settings, + default_timeout=None, + client_info=client_info, + ), + self.configure_contact_settings: gapic_v1.method.wrap_method( + self.configure_contact_settings, + default_timeout=None, + client_info=client_info, + ), + self.export_registration: gapic_v1.method.wrap_method( + self.export_registration, default_timeout=None, client_info=client_info, + ), + self.delete_registration: gapic_v1.method.wrap_method( + self.delete_registration, default_timeout=None, client_info=client_info, + ), + self.retrieve_authorization_code: gapic_v1.method.wrap_method( + self.retrieve_authorization_code, + default_timeout=None, + client_info=client_info, + ), + self.reset_authorization_code: gapic_v1.method.wrap_method( + self.reset_authorization_code, + default_timeout=None, + client_info=client_info, + ), + } + + def close(self): + """Closes resources associated with the transport. + + .. warning:: + Only call this method if the transport is NOT shared + with other clients - this may cause errors in other clients! + """ + raise NotImplementedError() + + @property + def operations_client(self) -> operations_v1.OperationsClient: + """Return the client designed to process long-running operations.""" + raise NotImplementedError() + + @property + def search_domains( + self, + ) -> Callable[ + [domains.SearchDomainsRequest], + Union[domains.SearchDomainsResponse, Awaitable[domains.SearchDomainsResponse]], + ]: + raise NotImplementedError() + + @property + def retrieve_register_parameters( + self, + ) -> Callable[ + [domains.RetrieveRegisterParametersRequest], + Union[ + domains.RetrieveRegisterParametersResponse, + Awaitable[domains.RetrieveRegisterParametersResponse], + ], + ]: + raise NotImplementedError() + + @property + def register_domain( + self, + ) -> Callable[ + [domains.RegisterDomainRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def retrieve_transfer_parameters( + self, + ) -> Callable[ + [domains.RetrieveTransferParametersRequest], + Union[ + domains.RetrieveTransferParametersResponse, + Awaitable[domains.RetrieveTransferParametersResponse], + ], + ]: + raise NotImplementedError() + + @property + def transfer_domain( + self, + ) -> Callable[ + [domains.TransferDomainRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def list_registrations( + self, + ) -> Callable[ + [domains.ListRegistrationsRequest], + Union[ + domains.ListRegistrationsResponse, + Awaitable[domains.ListRegistrationsResponse], + ], + ]: + raise NotImplementedError() + + @property + def get_registration( + self, + ) -> Callable[ + [domains.GetRegistrationRequest], + Union[domains.Registration, Awaitable[domains.Registration]], + ]: + raise NotImplementedError() + + @property + def update_registration( + self, + ) -> Callable[ + [domains.UpdateRegistrationRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def configure_management_settings( + self, + ) -> Callable[ + [domains.ConfigureManagementSettingsRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def configure_dns_settings( + self, + ) -> Callable[ + [domains.ConfigureDnsSettingsRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def configure_contact_settings( + self, + ) -> Callable[ + [domains.ConfigureContactSettingsRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def export_registration( + self, + ) -> Callable[ + [domains.ExportRegistrationRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def delete_registration( + self, + ) -> Callable[ + [domains.DeleteRegistrationRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + + @property + def retrieve_authorization_code( + self, + ) -> Callable[ + [domains.RetrieveAuthorizationCodeRequest], + Union[domains.AuthorizationCode, Awaitable[domains.AuthorizationCode]], + ]: + raise NotImplementedError() + + @property + def reset_authorization_code( + self, + ) -> Callable[ + [domains.ResetAuthorizationCodeRequest], + Union[domains.AuthorizationCode, Awaitable[domains.AuthorizationCode]], + ]: + raise NotImplementedError() + + +__all__ = ("DomainsTransport",) diff --git a/google/cloud/domains_v1/services/domains/transports/grpc.py b/google/cloud/domains_v1/services/domains/transports/grpc.py new file mode 100644 index 0000000..d4c7f2d --- /dev/null +++ b/google/cloud/domains_v1/services/domains/transports/grpc.py @@ -0,0 +1,748 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +import warnings +from typing import Callable, Dict, Optional, Sequence, Tuple, Union + +from google.api_core import grpc_helpers # type: ignore +from google.api_core import operations_v1 # type: ignore +from google.api_core import gapic_v1 # type: ignore +import google.auth # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore + +import grpc # type: ignore + +from google.cloud.domains_v1.types import domains +from google.longrunning import operations_pb2 # type: ignore +from .base import DomainsTransport, DEFAULT_CLIENT_INFO + + +class DomainsGrpcTransport(DomainsTransport): + """gRPC backend transport for Domains. + + The Cloud Domains API enables management and configuration of + domain names. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends protocol buffers over the wire using gRPC (which is built on + top of HTTP/2); the ``grpcio`` package must be installed. + """ + + _stubs: Dict[str, Callable] + + def __init__( + self, + *, + host: str = "domains.googleapis.com", + credentials: ga_credentials.Credentials = None, + credentials_file: str = None, + scopes: Sequence[str] = None, + channel: grpc.Channel = None, + api_mtls_endpoint: str = None, + client_cert_source: Callable[[], Tuple[bytes, bytes]] = None, + ssl_channel_credentials: grpc.ChannelCredentials = None, + client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to. + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is ignored if ``channel`` is provided. + credentials_file (Optional[str]): A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if ``channel`` is provided. + scopes (Optional(Sequence[str])): A list of scopes. This argument is + ignored if ``channel`` is provided. + channel (Optional[grpc.Channel]): A ``Channel`` instance through + which to make calls. + api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint. + If provided, it overrides the ``host`` argument and tries to create + a mutual TLS channel with client SSL credentials from + ``client_cert_source`` or application default SSL credentials. + client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): + Deprecated. A callback to provide client SSL certificate bytes and + private key bytes, both in PEM format. It is ignored if + ``api_mtls_endpoint`` is None. + ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials + for the grpc channel. It is ignored if ``channel`` is provided. + client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]): + A callback to provide client certificate bytes and private key bytes, + both in PEM format. It is used to configure a mutual TLS channel. It is + ignored if ``channel`` or ``ssl_channel_credentials`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + + Raises: + google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport + creation failed for any reason. + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + self._grpc_channel = None + self._ssl_channel_credentials = ssl_channel_credentials + self._stubs: Dict[str, Callable] = {} + self._operations_client = None + + if api_mtls_endpoint: + warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning) + if client_cert_source: + warnings.warn("client_cert_source is deprecated", DeprecationWarning) + + if channel: + # Ignore credentials if a channel was passed. + credentials = False + # If a channel was explicitly provided, set it. + self._grpc_channel = channel + self._ssl_channel_credentials = None + + else: + if api_mtls_endpoint: + host = api_mtls_endpoint + + # Create SSL credentials with client_cert_source or application + # default SSL credentials. + if client_cert_source: + cert, key = client_cert_source() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + else: + self._ssl_channel_credentials = SslCredentials().ssl_credentials + + else: + if client_cert_source_for_mtls and not ssl_channel_credentials: + cert, key = client_cert_source_for_mtls() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + + # The base transport sets the host, credentials and scopes + super().__init__( + host=host, + credentials=credentials, + credentials_file=credentials_file, + scopes=scopes, + quota_project_id=quota_project_id, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + ) + + if not self._grpc_channel: + self._grpc_channel = type(self).create_channel( + self._host, + credentials=self._credentials, + credentials_file=credentials_file, + scopes=self._scopes, + ssl_credentials=self._ssl_channel_credentials, + quota_project_id=quota_project_id, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + # Wrap messages. This must be done after self._grpc_channel exists + self._prep_wrapped_messages(client_info) + + @classmethod + def create_channel( + cls, + host: str = "domains.googleapis.com", + credentials: ga_credentials.Credentials = None, + credentials_file: str = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + **kwargs, + ) -> grpc.Channel: + """Create and return a gRPC channel object. + Args: + host (Optional[str]): The host for the channel to use. + credentials (Optional[~.Credentials]): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + credentials_file (Optional[str]): A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is mutually exclusive with credentials. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + kwargs (Optional[dict]): Keyword arguments, which are passed to the + channel creation. + Returns: + grpc.Channel: A gRPC channel object. + + Raises: + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + + return grpc_helpers.create_channel( + host, + credentials=credentials, + credentials_file=credentials_file, + quota_project_id=quota_project_id, + default_scopes=cls.AUTH_SCOPES, + scopes=scopes, + default_host=cls.DEFAULT_HOST, + **kwargs, + ) + + @property + def grpc_channel(self) -> grpc.Channel: + """Return the channel designed to connect to this service. + """ + return self._grpc_channel + + @property + def operations_client(self) -> operations_v1.OperationsClient: + """Create the client designed to process long-running operations. + + This property caches on the instance; repeated calls return the same + client. + """ + # Sanity check: Only create a new client if we do not already have one. + if self._operations_client is None: + self._operations_client = operations_v1.OperationsClient(self.grpc_channel) + + # Return the client from cache. + return self._operations_client + + @property + def search_domains( + self, + ) -> Callable[[domains.SearchDomainsRequest], domains.SearchDomainsResponse]: + r"""Return a callable for the search domains method over gRPC. + + Searches for available domain names similar to the provided + query. + + Availability results from this method are approximate; call + ``RetrieveRegisterParameters`` on a domain before registering to + confirm availability. + + Returns: + Callable[[~.SearchDomainsRequest], + ~.SearchDomainsResponse]: + 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 "search_domains" not in self._stubs: + self._stubs["search_domains"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/SearchDomains", + request_serializer=domains.SearchDomainsRequest.serialize, + response_deserializer=domains.SearchDomainsResponse.deserialize, + ) + return self._stubs["search_domains"] + + @property + def retrieve_register_parameters( + self, + ) -> Callable[ + [domains.RetrieveRegisterParametersRequest], + domains.RetrieveRegisterParametersResponse, + ]: + r"""Return a callable for the retrieve register parameters method over gRPC. + + Gets parameters needed to register a new domain name, including + price and up-to-date availability. Use the returned values to + call ``RegisterDomain``. + + Returns: + Callable[[~.RetrieveRegisterParametersRequest], + ~.RetrieveRegisterParametersResponse]: + 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 "retrieve_register_parameters" not in self._stubs: + self._stubs["retrieve_register_parameters"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RetrieveRegisterParameters", + request_serializer=domains.RetrieveRegisterParametersRequest.serialize, + response_deserializer=domains.RetrieveRegisterParametersResponse.deserialize, + ) + return self._stubs["retrieve_register_parameters"] + + @property + def register_domain( + self, + ) -> Callable[[domains.RegisterDomainRequest], operations_pb2.Operation]: + r"""Return a callable for the register domain method over gRPC. + + Registers a new domain name and creates a corresponding + ``Registration`` resource. + + Call ``RetrieveRegisterParameters`` first to check availability + of the domain name and determine parameters like price that are + needed to build a call to this method. + + A successful call creates a ``Registration`` resource in state + ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within + 1-2 minutes, indicating that the domain was successfully + registered. If the resource ends up in state + ``REGISTRATION_FAILED``, it indicates that the domain was not + registered successfully, and you can safely delete the resource + and retry registration. + + Returns: + Callable[[~.RegisterDomainRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "register_domain" not in self._stubs: + self._stubs["register_domain"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RegisterDomain", + request_serializer=domains.RegisterDomainRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["register_domain"] + + @property + def retrieve_transfer_parameters( + self, + ) -> Callable[ + [domains.RetrieveTransferParametersRequest], + domains.RetrieveTransferParametersResponse, + ]: + r"""Return a callable for the retrieve transfer parameters method over gRPC. + + Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Returns: + Callable[[~.RetrieveTransferParametersRequest], + ~.RetrieveTransferParametersResponse]: + 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 "retrieve_transfer_parameters" not in self._stubs: + self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RetrieveTransferParameters", + request_serializer=domains.RetrieveTransferParametersRequest.serialize, + response_deserializer=domains.RetrieveTransferParametersResponse.deserialize, + ) + return self._stubs["retrieve_transfer_parameters"] + + @property + def transfer_domain( + self, + ) -> Callable[[domains.TransferDomainRequest], operations_pb2.Operation]: + r"""Return a callable for the transfer domain method over gRPC. + + Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Returns: + Callable[[~.TransferDomainRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "transfer_domain" not in self._stubs: + self._stubs["transfer_domain"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/TransferDomain", + request_serializer=domains.TransferDomainRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["transfer_domain"] + + @property + def list_registrations( + self, + ) -> Callable[ + [domains.ListRegistrationsRequest], domains.ListRegistrationsResponse + ]: + r"""Return a callable for the list registrations method over gRPC. + + Lists the ``Registration`` resources in a project. + + Returns: + Callable[[~.ListRegistrationsRequest], + ~.ListRegistrationsResponse]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "list_registrations" not in self._stubs: + self._stubs["list_registrations"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ListRegistrations", + request_serializer=domains.ListRegistrationsRequest.serialize, + response_deserializer=domains.ListRegistrationsResponse.deserialize, + ) + return self._stubs["list_registrations"] + + @property + def get_registration( + self, + ) -> Callable[[domains.GetRegistrationRequest], domains.Registration]: + r"""Return a callable for the get registration method over gRPC. + + Gets the details of a ``Registration`` resource. + + Returns: + Callable[[~.GetRegistrationRequest], + ~.Registration]: + 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_registration" not in self._stubs: + self._stubs["get_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/GetRegistration", + request_serializer=domains.GetRegistrationRequest.serialize, + response_deserializer=domains.Registration.deserialize, + ) + return self._stubs["get_registration"] + + @property + def update_registration( + self, + ) -> Callable[[domains.UpdateRegistrationRequest], operations_pb2.Operation]: + r"""Return a callable for the update registration method over gRPC. + + Updates select fields of a ``Registration`` resource, notably + ``labels``. To update other fields, use the appropriate custom + update method: + + - To update management settings, see + ``ConfigureManagementSettings`` + - To update DNS configuration, see ``ConfigureDnsSettings`` + - To update contact information, see + ``ConfigureContactSettings`` + + Returns: + Callable[[~.UpdateRegistrationRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "update_registration" not in self._stubs: + self._stubs["update_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/UpdateRegistration", + request_serializer=domains.UpdateRegistrationRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["update_registration"] + + @property + def configure_management_settings( + self, + ) -> Callable[ + [domains.ConfigureManagementSettingsRequest], operations_pb2.Operation + ]: + r"""Return a callable for the configure management settings method over gRPC. + + Updates a ``Registration``'s management settings. + + Returns: + Callable[[~.ConfigureManagementSettingsRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "configure_management_settings" not in self._stubs: + self._stubs[ + "configure_management_settings" + ] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ConfigureManagementSettings", + request_serializer=domains.ConfigureManagementSettingsRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["configure_management_settings"] + + @property + def configure_dns_settings( + self, + ) -> Callable[[domains.ConfigureDnsSettingsRequest], operations_pb2.Operation]: + r"""Return a callable for the configure dns settings method over gRPC. + + Updates a ``Registration``'s DNS settings. + + Returns: + Callable[[~.ConfigureDnsSettingsRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "configure_dns_settings" not in self._stubs: + self._stubs["configure_dns_settings"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ConfigureDnsSettings", + request_serializer=domains.ConfigureDnsSettingsRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["configure_dns_settings"] + + @property + def configure_contact_settings( + self, + ) -> Callable[[domains.ConfigureContactSettingsRequest], operations_pb2.Operation]: + r"""Return a callable for the configure contact settings method over gRPC. + + Updates a ``Registration``'s contact settings. Some changes + require confirmation by the domain's registrant contact . + + Returns: + Callable[[~.ConfigureContactSettingsRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "configure_contact_settings" not in self._stubs: + self._stubs["configure_contact_settings"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ConfigureContactSettings", + request_serializer=domains.ConfigureContactSettingsRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["configure_contact_settings"] + + @property + def export_registration( + self, + ) -> Callable[[domains.ExportRegistrationRequest], operations_pb2.Operation]: + r"""Return a callable for the export registration method over gRPC. + + Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. + + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Returns: + Callable[[~.ExportRegistrationRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "export_registration" not in self._stubs: + self._stubs["export_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ExportRegistration", + request_serializer=domains.ExportRegistrationRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["export_registration"] + + @property + def delete_registration( + self, + ) -> Callable[[domains.DeleteRegistrationRequest], operations_pb2.Operation]: + r"""Return a callable for the delete registration method over gRPC. + + Deletes a ``Registration`` resource. + + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: + + - ``state`` is ``EXPORTED`` with ``expire_time`` in the past + - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Returns: + Callable[[~.DeleteRegistrationRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "delete_registration" not in self._stubs: + self._stubs["delete_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/DeleteRegistration", + request_serializer=domains.DeleteRegistrationRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["delete_registration"] + + @property + def retrieve_authorization_code( + self, + ) -> Callable[ + [domains.RetrieveAuthorizationCodeRequest], domains.AuthorizationCode + ]: + r"""Return a callable for the retrieve authorization code method over gRPC. + + Gets the authorization code of the ``Registration`` for the + purpose of transferring the domain to another registrar. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Returns: + Callable[[~.RetrieveAuthorizationCodeRequest], + ~.AuthorizationCode]: + 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 "retrieve_authorization_code" not in self._stubs: + self._stubs["retrieve_authorization_code"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RetrieveAuthorizationCode", + request_serializer=domains.RetrieveAuthorizationCodeRequest.serialize, + response_deserializer=domains.AuthorizationCode.deserialize, + ) + return self._stubs["retrieve_authorization_code"] + + @property + def reset_authorization_code( + self, + ) -> Callable[[domains.ResetAuthorizationCodeRequest], domains.AuthorizationCode]: + r"""Return a callable for the reset authorization code method over gRPC. + + Resets the authorization code of the ``Registration`` to a new + random string. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Returns: + Callable[[~.ResetAuthorizationCodeRequest], + ~.AuthorizationCode]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "reset_authorization_code" not in self._stubs: + self._stubs["reset_authorization_code"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ResetAuthorizationCode", + request_serializer=domains.ResetAuthorizationCodeRequest.serialize, + response_deserializer=domains.AuthorizationCode.deserialize, + ) + return self._stubs["reset_authorization_code"] + + def close(self): + self.grpc_channel.close() + + +__all__ = ("DomainsGrpcTransport",) diff --git a/google/cloud/domains_v1/services/domains/transports/grpc_asyncio.py b/google/cloud/domains_v1/services/domains/transports/grpc_asyncio.py new file mode 100644 index 0000000..50c2521 --- /dev/null +++ b/google/cloud/domains_v1/services/domains/transports/grpc_asyncio.py @@ -0,0 +1,768 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +import warnings +from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union + +from google.api_core import gapic_v1 # type: ignore +from google.api_core import grpc_helpers_async # type: ignore +from google.api_core import operations_v1 # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +import packaging.version + +import grpc # type: ignore +from grpc.experimental import aio # type: ignore + +from google.cloud.domains_v1.types import domains +from google.longrunning import operations_pb2 # type: ignore +from .base import DomainsTransport, DEFAULT_CLIENT_INFO +from .grpc import DomainsGrpcTransport + + +class DomainsGrpcAsyncIOTransport(DomainsTransport): + """gRPC AsyncIO backend transport for Domains. + + The Cloud Domains API enables management and configuration of + domain names. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends protocol buffers over the wire using gRPC (which is built on + top of HTTP/2); the ``grpcio`` package must be installed. + """ + + _grpc_channel: aio.Channel + _stubs: Dict[str, Callable] = {} + + @classmethod + def create_channel( + cls, + host: str = "domains.googleapis.com", + credentials: ga_credentials.Credentials = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + quota_project_id: Optional[str] = None, + **kwargs, + ) -> aio.Channel: + """Create and return a gRPC AsyncIO channel object. + Args: + host (Optional[str]): The host for the channel to use. + credentials (Optional[~.Credentials]): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + credentials_file (Optional[str]): A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if ``channel`` is provided. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + kwargs (Optional[dict]): Keyword arguments, which are passed to the + channel creation. + Returns: + aio.Channel: A gRPC AsyncIO channel object. + """ + + return grpc_helpers_async.create_channel( + host, + credentials=credentials, + credentials_file=credentials_file, + quota_project_id=quota_project_id, + default_scopes=cls.AUTH_SCOPES, + scopes=scopes, + default_host=cls.DEFAULT_HOST, + **kwargs, + ) + + def __init__( + self, + *, + host: str = "domains.googleapis.com", + credentials: ga_credentials.Credentials = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + channel: aio.Channel = None, + api_mtls_endpoint: str = None, + client_cert_source: Callable[[], Tuple[bytes, bytes]] = None, + ssl_channel_credentials: grpc.ChannelCredentials = None, + client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None, + quota_project_id=None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + ) -> None: + """Instantiate the transport. + + Args: + host (Optional[str]): + The hostname to connect to. + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is ignored if ``channel`` is provided. + credentials_file (Optional[str]): A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if ``channel`` is provided. + scopes (Optional[Sequence[str]]): A optional list of scopes needed for this + service. These are only used when credentials are not specified and + are passed to :func:`google.auth.default`. + channel (Optional[aio.Channel]): A ``Channel`` instance through + which to make calls. + api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint. + If provided, it overrides the ``host`` argument and tries to create + a mutual TLS channel with client SSL credentials from + ``client_cert_source`` or application default SSL credentials. + client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]): + Deprecated. A callback to provide client SSL certificate bytes and + private key bytes, both in PEM format. It is ignored if + ``api_mtls_endpoint`` is None. + ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials + for the grpc channel. It is ignored if ``channel`` is provided. + client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]): + A callback to provide client certificate bytes and private key bytes, + both in PEM format. It is used to configure a mutual TLS channel. It is + ignored if ``channel`` or ``ssl_channel_credentials`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + + Raises: + google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport + creation failed for any reason. + google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials`` + and ``credentials_file`` are passed. + """ + self._grpc_channel = None + self._ssl_channel_credentials = ssl_channel_credentials + self._stubs: Dict[str, Callable] = {} + self._operations_client = None + + if api_mtls_endpoint: + warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning) + if client_cert_source: + warnings.warn("client_cert_source is deprecated", DeprecationWarning) + + if channel: + # Ignore credentials if a channel was passed. + credentials = False + # If a channel was explicitly provided, set it. + self._grpc_channel = channel + self._ssl_channel_credentials = None + else: + if api_mtls_endpoint: + host = api_mtls_endpoint + + # Create SSL credentials with client_cert_source or application + # default SSL credentials. + if client_cert_source: + cert, key = client_cert_source() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + else: + self._ssl_channel_credentials = SslCredentials().ssl_credentials + + else: + if client_cert_source_for_mtls and not ssl_channel_credentials: + cert, key = client_cert_source_for_mtls() + self._ssl_channel_credentials = grpc.ssl_channel_credentials( + certificate_chain=cert, private_key=key + ) + + # The base transport sets the host, credentials and scopes + super().__init__( + host=host, + credentials=credentials, + credentials_file=credentials_file, + scopes=scopes, + quota_project_id=quota_project_id, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + ) + + if not self._grpc_channel: + self._grpc_channel = type(self).create_channel( + self._host, + credentials=self._credentials, + credentials_file=credentials_file, + scopes=self._scopes, + ssl_credentials=self._ssl_channel_credentials, + quota_project_id=quota_project_id, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + # Wrap messages. This must be done after self._grpc_channel exists + self._prep_wrapped_messages(client_info) + + @property + def grpc_channel(self) -> aio.Channel: + """Create the channel designed to connect to this service. + + This property caches on the instance; repeated calls return + the same channel. + """ + # Return the channel from cache. + return self._grpc_channel + + @property + def operations_client(self) -> operations_v1.OperationsAsyncClient: + """Create the client designed to process long-running operations. + + This property caches on the instance; repeated calls return the same + client. + """ + # Sanity check: Only create a new client if we do not already have one. + if self._operations_client is None: + self._operations_client = operations_v1.OperationsAsyncClient( + self.grpc_channel + ) + + # Return the client from cache. + return self._operations_client + + @property + def search_domains( + self, + ) -> Callable[ + [domains.SearchDomainsRequest], Awaitable[domains.SearchDomainsResponse] + ]: + r"""Return a callable for the search domains method over gRPC. + + Searches for available domain names similar to the provided + query. + + Availability results from this method are approximate; call + ``RetrieveRegisterParameters`` on a domain before registering to + confirm availability. + + Returns: + Callable[[~.SearchDomainsRequest], + Awaitable[~.SearchDomainsResponse]]: + 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 "search_domains" not in self._stubs: + self._stubs["search_domains"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/SearchDomains", + request_serializer=domains.SearchDomainsRequest.serialize, + response_deserializer=domains.SearchDomainsResponse.deserialize, + ) + return self._stubs["search_domains"] + + @property + def retrieve_register_parameters( + self, + ) -> Callable[ + [domains.RetrieveRegisterParametersRequest], + Awaitable[domains.RetrieveRegisterParametersResponse], + ]: + r"""Return a callable for the retrieve register parameters method over gRPC. + + Gets parameters needed to register a new domain name, including + price and up-to-date availability. Use the returned values to + call ``RegisterDomain``. + + Returns: + Callable[[~.RetrieveRegisterParametersRequest], + Awaitable[~.RetrieveRegisterParametersResponse]]: + 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 "retrieve_register_parameters" not in self._stubs: + self._stubs["retrieve_register_parameters"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RetrieveRegisterParameters", + request_serializer=domains.RetrieveRegisterParametersRequest.serialize, + response_deserializer=domains.RetrieveRegisterParametersResponse.deserialize, + ) + return self._stubs["retrieve_register_parameters"] + + @property + def register_domain( + self, + ) -> Callable[[domains.RegisterDomainRequest], Awaitable[operations_pb2.Operation]]: + r"""Return a callable for the register domain method over gRPC. + + Registers a new domain name and creates a corresponding + ``Registration`` resource. + + Call ``RetrieveRegisterParameters`` first to check availability + of the domain name and determine parameters like price that are + needed to build a call to this method. + + A successful call creates a ``Registration`` resource in state + ``REGISTRATION_PENDING``, which resolves to ``ACTIVE`` within + 1-2 minutes, indicating that the domain was successfully + registered. If the resource ends up in state + ``REGISTRATION_FAILED``, it indicates that the domain was not + registered successfully, and you can safely delete the resource + and retry registration. + + Returns: + Callable[[~.RegisterDomainRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "register_domain" not in self._stubs: + self._stubs["register_domain"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RegisterDomain", + request_serializer=domains.RegisterDomainRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["register_domain"] + + @property + def retrieve_transfer_parameters( + self, + ) -> Callable[ + [domains.RetrieveTransferParametersRequest], + Awaitable[domains.RetrieveTransferParametersResponse], + ]: + r"""Return a callable for the retrieve transfer parameters method over gRPC. + + Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Returns: + Callable[[~.RetrieveTransferParametersRequest], + Awaitable[~.RetrieveTransferParametersResponse]]: + 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 "retrieve_transfer_parameters" not in self._stubs: + self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RetrieveTransferParameters", + request_serializer=domains.RetrieveTransferParametersRequest.serialize, + response_deserializer=domains.RetrieveTransferParametersResponse.deserialize, + ) + return self._stubs["retrieve_transfer_parameters"] + + @property + def transfer_domain( + self, + ) -> Callable[[domains.TransferDomainRequest], Awaitable[operations_pb2.Operation]]: + r"""Return a callable for the transfer domain method over gRPC. + + Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Returns: + Callable[[~.TransferDomainRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "transfer_domain" not in self._stubs: + self._stubs["transfer_domain"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/TransferDomain", + request_serializer=domains.TransferDomainRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["transfer_domain"] + + @property + def list_registrations( + self, + ) -> Callable[ + [domains.ListRegistrationsRequest], Awaitable[domains.ListRegistrationsResponse] + ]: + r"""Return a callable for the list registrations method over gRPC. + + Lists the ``Registration`` resources in a project. + + Returns: + Callable[[~.ListRegistrationsRequest], + Awaitable[~.ListRegistrationsResponse]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "list_registrations" not in self._stubs: + self._stubs["list_registrations"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ListRegistrations", + request_serializer=domains.ListRegistrationsRequest.serialize, + response_deserializer=domains.ListRegistrationsResponse.deserialize, + ) + return self._stubs["list_registrations"] + + @property + def get_registration( + self, + ) -> Callable[[domains.GetRegistrationRequest], Awaitable[domains.Registration]]: + r"""Return a callable for the get registration method over gRPC. + + Gets the details of a ``Registration`` resource. + + Returns: + Callable[[~.GetRegistrationRequest], + Awaitable[~.Registration]]: + 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_registration" not in self._stubs: + self._stubs["get_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/GetRegistration", + request_serializer=domains.GetRegistrationRequest.serialize, + response_deserializer=domains.Registration.deserialize, + ) + return self._stubs["get_registration"] + + @property + def update_registration( + self, + ) -> Callable[ + [domains.UpdateRegistrationRequest], Awaitable[operations_pb2.Operation] + ]: + r"""Return a callable for the update registration method over gRPC. + + Updates select fields of a ``Registration`` resource, notably + ``labels``. To update other fields, use the appropriate custom + update method: + + - To update management settings, see + ``ConfigureManagementSettings`` + - To update DNS configuration, see ``ConfigureDnsSettings`` + - To update contact information, see + ``ConfigureContactSettings`` + + Returns: + Callable[[~.UpdateRegistrationRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "update_registration" not in self._stubs: + self._stubs["update_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/UpdateRegistration", + request_serializer=domains.UpdateRegistrationRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["update_registration"] + + @property + def configure_management_settings( + self, + ) -> Callable[ + [domains.ConfigureManagementSettingsRequest], + Awaitable[operations_pb2.Operation], + ]: + r"""Return a callable for the configure management settings method over gRPC. + + Updates a ``Registration``'s management settings. + + Returns: + Callable[[~.ConfigureManagementSettingsRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "configure_management_settings" not in self._stubs: + self._stubs[ + "configure_management_settings" + ] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ConfigureManagementSettings", + request_serializer=domains.ConfigureManagementSettingsRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["configure_management_settings"] + + @property + def configure_dns_settings( + self, + ) -> Callable[ + [domains.ConfigureDnsSettingsRequest], Awaitable[operations_pb2.Operation] + ]: + r"""Return a callable for the configure dns settings method over gRPC. + + Updates a ``Registration``'s DNS settings. + + Returns: + Callable[[~.ConfigureDnsSettingsRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "configure_dns_settings" not in self._stubs: + self._stubs["configure_dns_settings"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ConfigureDnsSettings", + request_serializer=domains.ConfigureDnsSettingsRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["configure_dns_settings"] + + @property + def configure_contact_settings( + self, + ) -> Callable[ + [domains.ConfigureContactSettingsRequest], Awaitable[operations_pb2.Operation] + ]: + r"""Return a callable for the configure contact settings method over gRPC. + + Updates a ``Registration``'s contact settings. Some changes + require confirmation by the domain's registrant contact . + + Returns: + Callable[[~.ConfigureContactSettingsRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "configure_contact_settings" not in self._stubs: + self._stubs["configure_contact_settings"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ConfigureContactSettings", + request_serializer=domains.ConfigureContactSettingsRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["configure_contact_settings"] + + @property + def export_registration( + self, + ) -> Callable[ + [domains.ExportRegistrationRequest], Awaitable[operations_pb2.Operation] + ]: + r"""Return a callable for the export registration method over gRPC. + + Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. + + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Returns: + Callable[[~.ExportRegistrationRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "export_registration" not in self._stubs: + self._stubs["export_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ExportRegistration", + request_serializer=domains.ExportRegistrationRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["export_registration"] + + @property + def delete_registration( + self, + ) -> Callable[ + [domains.DeleteRegistrationRequest], Awaitable[operations_pb2.Operation] + ]: + r"""Return a callable for the delete registration method over gRPC. + + Deletes a ``Registration`` resource. + + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: + + - ``state`` is ``EXPORTED`` with ``expire_time`` in the past + - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. + + Returns: + Callable[[~.DeleteRegistrationRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "delete_registration" not in self._stubs: + self._stubs["delete_registration"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/DeleteRegistration", + request_serializer=domains.DeleteRegistrationRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["delete_registration"] + + @property + def retrieve_authorization_code( + self, + ) -> Callable[ + [domains.RetrieveAuthorizationCodeRequest], Awaitable[domains.AuthorizationCode] + ]: + r"""Return a callable for the retrieve authorization code method over gRPC. + + Gets the authorization code of the ``Registration`` for the + purpose of transferring the domain to another registrar. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Returns: + Callable[[~.RetrieveAuthorizationCodeRequest], + Awaitable[~.AuthorizationCode]]: + 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 "retrieve_authorization_code" not in self._stubs: + self._stubs["retrieve_authorization_code"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/RetrieveAuthorizationCode", + request_serializer=domains.RetrieveAuthorizationCodeRequest.serialize, + response_deserializer=domains.AuthorizationCode.deserialize, + ) + return self._stubs["retrieve_authorization_code"] + + @property + def reset_authorization_code( + self, + ) -> Callable[ + [domains.ResetAuthorizationCodeRequest], Awaitable[domains.AuthorizationCode] + ]: + r"""Return a callable for the reset authorization code method over gRPC. + + Resets the authorization code of the ``Registration`` to a new + random string. + + You can call this method only after 60 days have elapsed since + the initial domain registration. + + Returns: + Callable[[~.ResetAuthorizationCodeRequest], + Awaitable[~.AuthorizationCode]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "reset_authorization_code" not in self._stubs: + self._stubs["reset_authorization_code"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1.Domains/ResetAuthorizationCode", + request_serializer=domains.ResetAuthorizationCodeRequest.serialize, + response_deserializer=domains.AuthorizationCode.deserialize, + ) + return self._stubs["reset_authorization_code"] + + def close(self): + return self.grpc_channel.close() + + +__all__ = ("DomainsGrpcAsyncIOTransport",) diff --git a/google/cloud/domains_v1/types/__init__.py b/google/cloud/domains_v1/types/__init__.py new file mode 100644 index 0000000..2ccb2c4 --- /dev/null +++ b/google/cloud/domains_v1/types/__init__.py @@ -0,0 +1,82 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +from .domains import ( + AuthorizationCode, + ConfigureContactSettingsRequest, + ConfigureDnsSettingsRequest, + ConfigureManagementSettingsRequest, + ContactSettings, + DeleteRegistrationRequest, + DnsSettings, + ExportRegistrationRequest, + GetRegistrationRequest, + ListRegistrationsRequest, + ListRegistrationsResponse, + ManagementSettings, + OperationMetadata, + RegisterDomainRequest, + RegisterParameters, + Registration, + ResetAuthorizationCodeRequest, + RetrieveAuthorizationCodeRequest, + RetrieveRegisterParametersRequest, + RetrieveRegisterParametersResponse, + RetrieveTransferParametersRequest, + RetrieveTransferParametersResponse, + SearchDomainsRequest, + SearchDomainsResponse, + TransferDomainRequest, + TransferParameters, + UpdateRegistrationRequest, + ContactNotice, + ContactPrivacy, + DomainNotice, + TransferLockState, +) + +__all__ = ( + "AuthorizationCode", + "ConfigureContactSettingsRequest", + "ConfigureDnsSettingsRequest", + "ConfigureManagementSettingsRequest", + "ContactSettings", + "DeleteRegistrationRequest", + "DnsSettings", + "ExportRegistrationRequest", + "GetRegistrationRequest", + "ListRegistrationsRequest", + "ListRegistrationsResponse", + "ManagementSettings", + "OperationMetadata", + "RegisterDomainRequest", + "RegisterParameters", + "Registration", + "ResetAuthorizationCodeRequest", + "RetrieveAuthorizationCodeRequest", + "RetrieveRegisterParametersRequest", + "RetrieveRegisterParametersResponse", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", + "SearchDomainsRequest", + "SearchDomainsResponse", + "TransferDomainRequest", + "TransferParameters", + "UpdateRegistrationRequest", + "ContactNotice", + "ContactPrivacy", + "DomainNotice", + "TransferLockState", +) diff --git a/google/cloud/domains_v1/types/domains.py b/google/cloud/domains_v1/types/domains.py new file mode 100644 index 0000000..266855f --- /dev/null +++ b/google/cloud/domains_v1/types/domains.py @@ -0,0 +1,986 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +import proto # type: ignore + +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore +from google.type import money_pb2 # type: ignore +from google.type import postal_address_pb2 # type: ignore + + +__protobuf__ = proto.module( + package="google.cloud.domains.v1", + manifest={ + "ContactPrivacy", + "DomainNotice", + "ContactNotice", + "TransferLockState", + "Registration", + "ManagementSettings", + "DnsSettings", + "ContactSettings", + "SearchDomainsRequest", + "SearchDomainsResponse", + "RetrieveRegisterParametersRequest", + "RetrieveRegisterParametersResponse", + "RegisterDomainRequest", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", + "TransferDomainRequest", + "ListRegistrationsRequest", + "ListRegistrationsResponse", + "GetRegistrationRequest", + "UpdateRegistrationRequest", + "ConfigureManagementSettingsRequest", + "ConfigureDnsSettingsRequest", + "ConfigureContactSettingsRequest", + "ExportRegistrationRequest", + "DeleteRegistrationRequest", + "RetrieveAuthorizationCodeRequest", + "ResetAuthorizationCodeRequest", + "RegisterParameters", + "TransferParameters", + "AuthorizationCode", + "OperationMetadata", + }, +) + + +class ContactPrivacy(proto.Enum): + r"""Defines a set of possible contact privacy settings for a + ``Registration``. + + `ICANN `__ maintains the WHOIS database, a + publicly accessible mapping from domain name to contact information, + and requires that each domain name have an entry. Choose from these + options to control how much information in your ``ContactSettings`` + is published. + """ + CONTACT_PRIVACY_UNSPECIFIED = 0 + PUBLIC_CONTACT_DATA = 1 + PRIVATE_CONTACT_DATA = 2 + REDACTED_CONTACT_DATA = 3 + + +class DomainNotice(proto.Enum): + r"""Notices about special properties of certain domains.""" + DOMAIN_NOTICE_UNSPECIFIED = 0 + HSTS_PRELOADED = 1 + + +class ContactNotice(proto.Enum): + r"""Notices related to contact information.""" + CONTACT_NOTICE_UNSPECIFIED = 0 + PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT = 1 + + +class TransferLockState(proto.Enum): + r"""Possible states of a ``Registration``'s transfer lock.""" + TRANSFER_LOCK_STATE_UNSPECIFIED = 0 + UNLOCKED = 1 + LOCKED = 2 + + +class Registration(proto.Message): + r"""The ``Registration`` resource facilitates managing and configuring + domain name registrations. + + There are several ways to create a new ``Registration`` resource: + + To create a new ``Registration`` resource, find a suitable domain + name by calling the ``SearchDomains`` method with a query to see + available domain name options. After choosing a name, call + ``RetrieveRegisterParameters`` to ensure availability and obtain + information like pricing, which is needed to build a call to + ``RegisterDomain``. + + Another way to create a new ``Registration`` is to transfer an + existing domain from another registrar. First, go to the current + registrar to unlock the domain for transfer and retrieve the + domain's transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to + ``TransferDomain``. + + Attributes: + name (str): + Output only. Name of the ``Registration`` resource, in the + format + ``projects/*/locations/*/registrations/``. + domain_name (str): + Required. Immutable. The domain name. Unicode + domain names must be expressed in Punycode + format. + create_time (google.protobuf.timestamp_pb2.Timestamp): + Output only. The creation timestamp of the ``Registration`` + resource. + expire_time (google.protobuf.timestamp_pb2.Timestamp): + Output only. The expiration timestamp of the + ``Registration``. + state (google.cloud.domains_v1.types.Registration.State): + Output only. The state of the ``Registration`` + issues (Sequence[google.cloud.domains_v1.types.Registration.Issue]): + Output only. The set of issues with the ``Registration`` + that require attention. + labels (Sequence[google.cloud.domains_v1.types.Registration.LabelsEntry]): + Set of labels associated with the ``Registration``. + management_settings (google.cloud.domains_v1.types.ManagementSettings): + Settings for management of the ``Registration``, including + renewal, billing, and transfer. You cannot update these with + the ``UpdateRegistration`` method. To update these settings, + use the ``ConfigureManagementSettings`` method. + dns_settings (google.cloud.domains_v1.types.DnsSettings): + Settings controlling the DNS configuration of the + ``Registration``. You cannot update these with the + ``UpdateRegistration`` method. To update these settings, use + the ``ConfigureDnsSettings`` method. + contact_settings (google.cloud.domains_v1.types.ContactSettings): + Required. Settings for contact information linked to the + ``Registration``. You cannot update these with the + ``UpdateRegistration`` method. To update these settings, use + the ``ConfigureContactSettings`` method. + pending_contact_settings (google.cloud.domains_v1.types.ContactSettings): + Output only. Pending contact settings for the + ``Registration``. Updates to the ``contact_settings`` field + that change its ``registrant_contact`` or ``privacy`` fields + require email confirmation by the ``registrant_contact`` + before taking effect. This field is set only if there are + pending updates to the ``contact_settings`` that have not + been confirmed. To confirm the changes, the + ``registrant_contact`` must follow the instructions in the + email they receive. + supported_privacy (Sequence[google.cloud.domains_v1.types.ContactPrivacy]): + Output only. Set of options for the + ``contact_settings.privacy`` field that this + ``Registration`` supports. + """ + + class State(proto.Enum): + r"""Possible states of a ``Registration``.""" + STATE_UNSPECIFIED = 0 + REGISTRATION_PENDING = 1 + REGISTRATION_FAILED = 2 + TRANSFER_PENDING = 3 + TRANSFER_FAILED = 4 + ACTIVE = 6 + SUSPENDED = 7 + EXPORTED = 8 + + class Issue(proto.Enum): + r"""Possible issues with a ``Registration`` that require attention.""" + ISSUE_UNSPECIFIED = 0 + CONTACT_SUPPORT = 1 + UNVERIFIED_EMAIL = 2 + + name = proto.Field(proto.STRING, number=1,) + domain_name = proto.Field(proto.STRING, number=2,) + create_time = proto.Field(proto.MESSAGE, number=3, message=timestamp_pb2.Timestamp,) + expire_time = proto.Field(proto.MESSAGE, number=6, message=timestamp_pb2.Timestamp,) + state = proto.Field(proto.ENUM, number=7, enum=State,) + issues = proto.RepeatedField(proto.ENUM, number=8, enum=Issue,) + labels = proto.MapField(proto.STRING, proto.STRING, number=9,) + management_settings = proto.Field( + proto.MESSAGE, number=10, message="ManagementSettings", + ) + dns_settings = proto.Field(proto.MESSAGE, number=11, message="DnsSettings",) + contact_settings = proto.Field(proto.MESSAGE, number=12, message="ContactSettings",) + pending_contact_settings = proto.Field( + proto.MESSAGE, number=13, message="ContactSettings", + ) + supported_privacy = proto.RepeatedField( + proto.ENUM, number=14, enum="ContactPrivacy", + ) + + +class ManagementSettings(proto.Message): + r"""Defines renewal, billing, and transfer settings for a + ``Registration``. + + Attributes: + renewal_method (google.cloud.domains_v1.types.ManagementSettings.RenewalMethod): + Output only. The renewal method for this ``Registration``. + transfer_lock_state (google.cloud.domains_v1.types.TransferLockState): + Controls whether the domain can be + transferred to another registrar. + """ + + class RenewalMethod(proto.Enum): + r"""Defines how the ``Registration`` is renewed.""" + RENEWAL_METHOD_UNSPECIFIED = 0 + AUTOMATIC_RENEWAL = 1 + MANUAL_RENEWAL = 2 + + renewal_method = proto.Field(proto.ENUM, number=3, enum=RenewalMethod,) + transfer_lock_state = proto.Field(proto.ENUM, number=4, enum="TransferLockState",) + + +class DnsSettings(proto.Message): + r"""Defines the DNS configuration of a ``Registration``, including name + servers, DNSSEC, and glue records. + + Attributes: + custom_dns (google.cloud.domains_v1.types.DnsSettings.CustomDns): + An arbitrary DNS provider identified by its + name servers. + google_domains_dns (google.cloud.domains_v1.types.DnsSettings.GoogleDomainsDns): + The free DNS zone provided by `Google + Domains `__. + glue_records (Sequence[google.cloud.domains_v1.types.DnsSettings.GlueRecord]): + The list of glue records for this ``Registration``. Commonly + empty. + """ + + class DsState(proto.Enum): + r"""The publication state of DS records for a ``Registration``.""" + DS_STATE_UNSPECIFIED = 0 + DS_RECORDS_UNPUBLISHED = 1 + DS_RECORDS_PUBLISHED = 2 + + class CustomDns(proto.Message): + r"""Configuration for an arbitrary DNS provider. + + Attributes: + name_servers (Sequence[str]): + Required. A list of name servers that store + the DNS zone for this domain. Each name server + is a domain name, with Unicode domain names + expressed in Punycode format. + ds_records (Sequence[google.cloud.domains_v1.types.DnsSettings.DsRecord]): + The list of DS records for this domain, which + are used to enable DNSSEC. The domain's DNS + provider can provide the values to set here. If + this field is empty, DNSSEC is disabled. + """ + + name_servers = proto.RepeatedField(proto.STRING, number=1,) + ds_records = proto.RepeatedField( + proto.MESSAGE, number=2, message="DnsSettings.DsRecord", + ) + + class GoogleDomainsDns(proto.Message): + r"""Configuration for using the free DNS zone provided by Google Domains + as a ``Registration``'s ``dns_provider``. You cannot configure the + DNS zone itself using the API. To configure the DNS zone, go to + `Google Domains `__. + + Attributes: + name_servers (Sequence[str]): + Output only. A list of name servers that + store the DNS zone for this domain. Each name + server is a domain name, with Unicode domain + names expressed in Punycode format. This field + is automatically populated with the name servers + assigned to the Google Domains DNS zone. + ds_state (google.cloud.domains_v1.types.DnsSettings.DsState): + Required. The state of DS records for this + domain. Used to enable or disable automatic + DNSSEC. + ds_records (Sequence[google.cloud.domains_v1.types.DnsSettings.DsRecord]): + Output only. The list of DS records published for this + domain. The list is automatically populated when + ``ds_state`` is ``DS_RECORDS_PUBLISHED``, otherwise it + remains empty. + """ + + name_servers = proto.RepeatedField(proto.STRING, number=1,) + ds_state = proto.Field(proto.ENUM, number=2, enum="DnsSettings.DsState",) + ds_records = proto.RepeatedField( + proto.MESSAGE, number=3, message="DnsSettings.DsRecord", + ) + + class DsRecord(proto.Message): + r"""Defines a Delegation Signer (DS) record, which is needed to + enable DNSSEC for a domain. It contains a digest (hash) of a + DNSKEY record that must be present in the domain's DNS zone. + + Attributes: + key_tag (int): + The key tag of the record. Must be set in + range 0 -- 65535. + algorithm (google.cloud.domains_v1.types.DnsSettings.DsRecord.Algorithm): + The algorithm used to generate the referenced + DNSKEY. + digest_type (google.cloud.domains_v1.types.DnsSettings.DsRecord.DigestType): + The hash function used to generate the digest + of the referenced DNSKEY. + digest (str): + The digest generated from the referenced + DNSKEY. + """ + + class Algorithm(proto.Enum): + r"""List of algorithms used to create a DNSKEY. Certain + algorithms are not supported for particular domains. + """ + ALGORITHM_UNSPECIFIED = 0 + RSAMD5 = 1 + DH = 2 + DSA = 3 + ECC = 4 + RSASHA1 = 5 + DSANSEC3SHA1 = 6 + RSASHA1NSEC3SHA1 = 7 + RSASHA256 = 8 + RSASHA512 = 10 + ECCGOST = 12 + ECDSAP256SHA256 = 13 + ECDSAP384SHA384 = 14 + ED25519 = 15 + ED448 = 16 + INDIRECT = 252 + PRIVATEDNS = 253 + PRIVATEOID = 254 + + class DigestType(proto.Enum): + r"""List of hash functions that may have been used to generate a + digest of a DNSKEY. + """ + DIGEST_TYPE_UNSPECIFIED = 0 + SHA1 = 1 + SHA256 = 2 + GOST3411 = 3 + SHA384 = 4 + + key_tag = proto.Field(proto.INT32, number=1,) + algorithm = proto.Field( + proto.ENUM, number=2, enum="DnsSettings.DsRecord.Algorithm", + ) + digest_type = proto.Field( + proto.ENUM, number=3, enum="DnsSettings.DsRecord.DigestType", + ) + digest = proto.Field(proto.STRING, number=4,) + + class GlueRecord(proto.Message): + r"""Defines a host on your domain that is a DNS name server for your + domain and/or other domains. Glue records are a way of making the IP + address of a name server known, even when it serves DNS queries for + its parent domain. For example, when ``ns.example.com`` is a name + server for ``example.com``, the host ``ns.example.com`` must have a + glue record to break the circular DNS reference. + + Attributes: + host_name (str): + Required. Domain name of the host in Punycode + format. + ipv4_addresses (Sequence[str]): + List of IPv4 addresses corresponding to this host in the + standard decimal format (e.g. ``198.51.100.1``). At least + one of ``ipv4_address`` and ``ipv6_address`` must be set. + ipv6_addresses (Sequence[str]): + List of IPv6 addresses corresponding to this host in the + standard hexadecimal format (e.g. ``2001:db8::``). At least + one of ``ipv4_address`` and ``ipv6_address`` must be set. + """ + + host_name = proto.Field(proto.STRING, number=1,) + ipv4_addresses = proto.RepeatedField(proto.STRING, number=2,) + ipv6_addresses = proto.RepeatedField(proto.STRING, number=3,) + + custom_dns = proto.Field( + proto.MESSAGE, number=1, oneof="dns_provider", message=CustomDns, + ) + google_domains_dns = proto.Field( + proto.MESSAGE, number=2, oneof="dns_provider", message=GoogleDomainsDns, + ) + glue_records = proto.RepeatedField(proto.MESSAGE, number=4, message=GlueRecord,) + + +class ContactSettings(proto.Message): + r"""Defines the contact information associated with a ``Registration``. + + `ICANN `__ requires all domain names to have + associated contact information. The ``registrant_contact`` is + considered the domain's legal owner, and often the other contacts + are identical. + + Attributes: + privacy (google.cloud.domains_v1.types.ContactPrivacy): + Required. Privacy setting for the contacts associated with + the ``Registration``. + registrant_contact (google.cloud.domains_v1.types.ContactSettings.Contact): + Required. The registrant contact for the ``Registration``. + + *Caution: Anyone with access to this email address, phone + number, and/or postal address can take control of the + domain.* + + *Warning: For new ``Registration``\ s, the registrant + receives an email confirmation that they must complete + within 15 days to avoid domain suspension.* + admin_contact (google.cloud.domains_v1.types.ContactSettings.Contact): + Required. The administrative contact for the + ``Registration``. + technical_contact (google.cloud.domains_v1.types.ContactSettings.Contact): + Required. The technical contact for the ``Registration``. + """ + + class Contact(proto.Message): + r"""Details required for a contact associated with a ``Registration``. + + Attributes: + postal_address (google.type.postal_address_pb2.PostalAddress): + Required. Postal address of the contact. + email (str): + Required. Email address of the contact. + phone_number (str): + Required. Phone number of the contact in international + format. For example, ``"+1-800-555-0123"``. + fax_number (str): + Fax number of the contact in international format. For + example, ``"+1-800-555-0123"``. + """ + + postal_address = proto.Field( + proto.MESSAGE, number=1, message=postal_address_pb2.PostalAddress, + ) + email = proto.Field(proto.STRING, number=2,) + phone_number = proto.Field(proto.STRING, number=3,) + fax_number = proto.Field(proto.STRING, number=4,) + + privacy = proto.Field(proto.ENUM, number=1, enum="ContactPrivacy",) + registrant_contact = proto.Field(proto.MESSAGE, number=2, message=Contact,) + admin_contact = proto.Field(proto.MESSAGE, number=3, message=Contact,) + technical_contact = proto.Field(proto.MESSAGE, number=4, message=Contact,) + + +class SearchDomainsRequest(proto.Message): + r"""Request for the ``SearchDomains`` method. + + Attributes: + query (str): + Required. String used to search for available + domain names. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + """ + + query = proto.Field(proto.STRING, number=1,) + location = proto.Field(proto.STRING, number=2,) + + +class SearchDomainsResponse(proto.Message): + r"""Response for the ``SearchDomains`` method. + + Attributes: + register_parameters (Sequence[google.cloud.domains_v1.types.RegisterParameters]): + Results of the domain name search. + """ + + register_parameters = proto.RepeatedField( + proto.MESSAGE, number=1, message="RegisterParameters", + ) + + +class RetrieveRegisterParametersRequest(proto.Message): + r"""Request for the ``RetrieveRegisterParameters`` method. + + Attributes: + domain_name (str): + Required. The domain name. Unicode domain + names must be expressed in Punycode format. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + """ + + domain_name = proto.Field(proto.STRING, number=1,) + location = proto.Field(proto.STRING, number=2,) + + +class RetrieveRegisterParametersResponse(proto.Message): + r"""Response for the ``RetrieveRegisterParameters`` method. + + Attributes: + register_parameters (google.cloud.domains_v1.types.RegisterParameters): + Parameters to use when calling the ``RegisterDomain`` + method. + """ + + register_parameters = proto.Field( + proto.MESSAGE, number=1, message="RegisterParameters", + ) + + +class RegisterDomainRequest(proto.Message): + r"""Request for the ``RegisterDomain`` method. + + Attributes: + parent (str): + Required. The parent resource of the ``Registration``. Must + be in the format ``projects/*/locations/*``. + registration (google.cloud.domains_v1.types.Registration): + Required. The complete ``Registration`` resource to be + created. + domain_notices (Sequence[google.cloud.domains_v1.types.DomainNotice]): + The list of domain notices that you acknowledge. Call + ``RetrieveRegisterParameters`` to see the notices that need + acknowledgement. + contact_notices (Sequence[google.cloud.domains_v1.types.ContactNotice]): + The list of contact notices that the caller acknowledges. + The notices needed here depend on the values specified in + ``registration.contact_settings``. + yearly_price (google.type.money_pb2.Money): + Required. Yearly price to register or renew + the domain. The value that should be put here + can be obtained from RetrieveRegisterParameters + or SearchDomains calls. + validate_only (bool): + When true, only validation is performed, without actually + registering the domain. Follows: + https://cloud.google.com/apis/design/design_patterns#request_validation + """ + + parent = proto.Field(proto.STRING, number=1,) + registration = proto.Field(proto.MESSAGE, number=2, message="Registration",) + domain_notices = proto.RepeatedField(proto.ENUM, number=3, enum="DomainNotice",) + contact_notices = proto.RepeatedField(proto.ENUM, number=4, enum="ContactNotice",) + yearly_price = proto.Field(proto.MESSAGE, number=5, message=money_pb2.Money,) + validate_only = proto.Field(proto.BOOL, number=6,) + + +class RetrieveTransferParametersRequest(proto.Message): + r"""Request for the ``RetrieveTransferParameters`` method. + + Attributes: + domain_name (str): + Required. The domain name. Unicode domain + names must be expressed in Punycode format. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + """ + + domain_name = proto.Field(proto.STRING, number=1,) + location = proto.Field(proto.STRING, number=2,) + + +class RetrieveTransferParametersResponse(proto.Message): + r"""Response for the ``RetrieveTransferParameters`` method. + + Attributes: + transfer_parameters (google.cloud.domains_v1.types.TransferParameters): + Parameters to use when calling the ``TransferDomain`` + method. + """ + + transfer_parameters = proto.Field( + proto.MESSAGE, number=1, message="TransferParameters", + ) + + +class TransferDomainRequest(proto.Message): + r"""Request for the ``TransferDomain`` method. + + Attributes: + parent (str): + Required. The parent resource of the ``Registration``. Must + be in the format ``projects/*/locations/*``. + registration (google.cloud.domains_v1.types.Registration): + Required. The complete ``Registration`` resource to be + created. + + You can leave ``registration.dns_settings`` unset to import + the domain's current DNS configuration from its current + registrar. Use this option only if you are sure that the + domain's current DNS service does not cease upon transfer, + as is often the case for DNS services provided for free by + the registrar. + contact_notices (Sequence[google.cloud.domains_v1.types.ContactNotice]): + The list of contact notices that you acknowledge. The + notices needed here depend on the values specified in + ``registration.contact_settings``. + yearly_price (google.type.money_pb2.Money): + Required. Acknowledgement of the price to transfer or renew + the domain for one year. Call ``RetrieveTransferParameters`` + to obtain the price, which you must acknowledge. + authorization_code (google.cloud.domains_v1.types.AuthorizationCode): + The domain's transfer authorization code. You + can obtain this from the domain's current + registrar. + validate_only (bool): + Validate the request without actually + transferring the domain. + """ + + parent = proto.Field(proto.STRING, number=1,) + registration = proto.Field(proto.MESSAGE, number=2, message="Registration",) + contact_notices = proto.RepeatedField(proto.ENUM, number=3, enum="ContactNotice",) + yearly_price = proto.Field(proto.MESSAGE, number=4, message=money_pb2.Money,) + authorization_code = proto.Field( + proto.MESSAGE, number=5, message="AuthorizationCode", + ) + validate_only = proto.Field(proto.BOOL, number=6,) + + +class ListRegistrationsRequest(proto.Message): + r"""Request for the ``ListRegistrations`` method. + + Attributes: + parent (str): + Required. The project and location from which to list + ``Registration``\ s, specified in the format + ``projects/*/locations/*``. + page_size (int): + Maximum number of results to return. + page_token (str): + When set to the ``next_page_token`` from a prior response, + provides the next page of results. + filter (str): + Filter expression to restrict the ``Registration``\ s + returned. + + The expression must specify the field name, a comparison + operator, and the value that you want to use for filtering. + The value must be a string, a number, a boolean, or an enum + value. The comparison operator should be one of =, !=, >, <, + >=, <=, or : for prefix or wildcard matches. + + For example, to filter to a specific domain name, use an + expression like ``domainName="example.com"``. You can also + check for the existence of a field; for example, to find + domains using custom DNS settings, use an expression like + ``dnsSettings.customDns:*``. + + You can also create compound filters by combining + expressions with the ``AND`` and ``OR`` operators. For + example, to find domains that are suspended or have specific + issues flagged, use an expression like + ``(state=SUSPENDED) OR (issue:*)``. + """ + + parent = proto.Field(proto.STRING, number=1,) + page_size = proto.Field(proto.INT32, number=2,) + page_token = proto.Field(proto.STRING, number=3,) + filter = proto.Field(proto.STRING, number=4,) + + +class ListRegistrationsResponse(proto.Message): + r"""Response for the ``ListRegistrations`` method. + + Attributes: + registrations (Sequence[google.cloud.domains_v1.types.Registration]): + A list of ``Registration``\ s. + next_page_token (str): + When present, there are more results to retrieve. Set + ``page_token`` to this value on a subsequent call to get the + next page of results. + """ + + @property + def raw_page(self): + return self + + registrations = proto.RepeatedField( + proto.MESSAGE, number=1, message="Registration", + ) + next_page_token = proto.Field(proto.STRING, number=2,) + + +class GetRegistrationRequest(proto.Message): + r"""Request for the ``GetRegistration`` method. + + Attributes: + name (str): + Required. The name of the ``Registration`` to get, in the + format ``projects/*/locations/*/registrations/*``. + """ + + name = proto.Field(proto.STRING, number=1,) + + +class UpdateRegistrationRequest(proto.Message): + r"""Request for the ``UpdateRegistration`` method. + + Attributes: + registration (google.cloud.domains_v1.types.Registration): + Fields of the ``Registration`` to update. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to update + as a comma-separated list. For example, if only the labels + are being updated, the ``update_mask`` is ``"labels"``. + """ + + registration = proto.Field(proto.MESSAGE, number=1, message="Registration",) + update_mask = proto.Field( + proto.MESSAGE, number=2, message=field_mask_pb2.FieldMask, + ) + + +class ConfigureManagementSettingsRequest(proto.Message): + r"""Request for the ``ConfigureManagementSettings`` method. + + Attributes: + registration (str): + Required. The name of the ``Registration`` whose management + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + management_settings (google.cloud.domains_v1.types.ManagementSettings): + Fields of the ``ManagementSettings`` to update. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to update + as a comma-separated list. For example, if only the transfer + lock is being updated, the ``update_mask`` is + ``"transfer_lock_state"``. + """ + + registration = proto.Field(proto.STRING, number=1,) + management_settings = proto.Field( + proto.MESSAGE, number=2, message="ManagementSettings", + ) + update_mask = proto.Field( + proto.MESSAGE, number=3, message=field_mask_pb2.FieldMask, + ) + + +class ConfigureDnsSettingsRequest(proto.Message): + r"""Request for the ``ConfigureDnsSettings`` method. + + Attributes: + registration (str): + Required. The name of the ``Registration`` whose DNS + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + dns_settings (google.cloud.domains_v1.types.DnsSettings): + Fields of the ``DnsSettings`` to update. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to update + as a comma-separated list. For example, if only the name + servers are being updated for an existing Custom DNS + configuration, the ``update_mask`` is + ``"custom_dns.name_servers"``. + + When changing the DNS provider from one type to another, + pass the new provider's field name as part of the field + mask. For example, when changing from a Google Domains DNS + configuration to a Custom DNS configuration, the + ``update_mask`` is ``"custom_dns"``. // + validate_only (bool): + Validate the request without actually + updating the DNS settings. + """ + + registration = proto.Field(proto.STRING, number=1,) + dns_settings = proto.Field(proto.MESSAGE, number=2, message="DnsSettings",) + update_mask = proto.Field( + proto.MESSAGE, number=3, message=field_mask_pb2.FieldMask, + ) + validate_only = proto.Field(proto.BOOL, number=4,) + + +class ConfigureContactSettingsRequest(proto.Message): + r"""Request for the ``ConfigureContactSettings`` method. + + Attributes: + registration (str): + Required. The name of the ``Registration`` whose contact + settings are being updated, in the format + ``projects/*/locations/*/registrations/*``. + contact_settings (google.cloud.domains_v1.types.ContactSettings): + Fields of the ``ContactSettings`` to update. + update_mask (google.protobuf.field_mask_pb2.FieldMask): + Required. The field mask describing which fields to update + as a comma-separated list. For example, if only the + registrant contact is being updated, the ``update_mask`` is + ``"registrant_contact"``. + contact_notices (Sequence[google.cloud.domains_v1.types.ContactNotice]): + The list of contact notices that the caller acknowledges. + The notices needed here depend on the values specified in + ``contact_settings``. + validate_only (bool): + Validate the request without actually + updating the contact settings. + """ + + registration = proto.Field(proto.STRING, number=1,) + contact_settings = proto.Field(proto.MESSAGE, number=2, message="ContactSettings",) + update_mask = proto.Field( + proto.MESSAGE, number=3, message=field_mask_pb2.FieldMask, + ) + contact_notices = proto.RepeatedField(proto.ENUM, number=4, enum="ContactNotice",) + validate_only = proto.Field(proto.BOOL, number=5,) + + +class ExportRegistrationRequest(proto.Message): + r"""Request for the ``ExportRegistration`` method. + + Attributes: + name (str): + Required. The name of the ``Registration`` to export, in the + format ``projects/*/locations/*/registrations/*``. + """ + + name = proto.Field(proto.STRING, number=1,) + + +class DeleteRegistrationRequest(proto.Message): + r"""Request for the ``DeleteRegistration`` method. + + Attributes: + name (str): + Required. The name of the ``Registration`` to delete, in the + format ``projects/*/locations/*/registrations/*``. + """ + + name = proto.Field(proto.STRING, number=1,) + + +class RetrieveAuthorizationCodeRequest(proto.Message): + r"""Request for the ``RetrieveAuthorizationCode`` method. + + Attributes: + registration (str): + Required. The name of the ``Registration`` whose + authorization code is being retrieved, in the format + ``projects/*/locations/*/registrations/*``. + """ + + registration = proto.Field(proto.STRING, number=1,) + + +class ResetAuthorizationCodeRequest(proto.Message): + r"""Request for the ``ResetAuthorizationCode`` method. + + Attributes: + registration (str): + Required. The name of the ``Registration`` whose + authorization code is being reset, in the format + ``projects/*/locations/*/registrations/*``. + """ + + registration = proto.Field(proto.STRING, number=1,) + + +class RegisterParameters(proto.Message): + r"""Parameters required to register a new domain. + + Attributes: + domain_name (str): + The domain name. Unicode domain names are + expressed in Punycode format. + availability (google.cloud.domains_v1.types.RegisterParameters.Availability): + Indicates whether the domain is available for registration. + This value is accurate when obtained by calling + ``RetrieveRegisterParameters``, but is approximate when + obtained by calling ``SearchDomains``. + supported_privacy (Sequence[google.cloud.domains_v1.types.ContactPrivacy]): + Contact privacy options that the domain + supports. + domain_notices (Sequence[google.cloud.domains_v1.types.DomainNotice]): + Notices about special properties of the + domain. + yearly_price (google.type.money_pb2.Money): + Price to register or renew the domain for one + year. + """ + + class Availability(proto.Enum): + r"""Possible availability states of a domain name.""" + AVAILABILITY_UNSPECIFIED = 0 + AVAILABLE = 1 + UNAVAILABLE = 2 + UNSUPPORTED = 3 + UNKNOWN = 4 + + domain_name = proto.Field(proto.STRING, number=1,) + availability = proto.Field(proto.ENUM, number=2, enum=Availability,) + supported_privacy = proto.RepeatedField( + proto.ENUM, number=3, enum="ContactPrivacy", + ) + domain_notices = proto.RepeatedField(proto.ENUM, number=4, enum="DomainNotice",) + yearly_price = proto.Field(proto.MESSAGE, number=5, message=money_pb2.Money,) + + +class TransferParameters(proto.Message): + r"""Parameters required to transfer a domain from another + registrar. + + Attributes: + domain_name (str): + The domain name. Unicode domain names are + expressed in Punycode format. + current_registrar (str): + The registrar that currently manages the + domain. + name_servers (Sequence[str]): + The name servers that currently store the + configuration of the domain. + transfer_lock_state (google.cloud.domains_v1.types.TransferLockState): + Indicates whether the domain is protected by a transfer + lock. For a transfer to succeed, this must show + ``UNLOCKED``. To unlock a domain, go to its current + registrar. + supported_privacy (Sequence[google.cloud.domains_v1.types.ContactPrivacy]): + Contact privacy options that the domain + supports. + yearly_price (google.type.money_pb2.Money): + Price to transfer or renew the domain for one + year. + """ + + domain_name = proto.Field(proto.STRING, number=1,) + current_registrar = proto.Field(proto.STRING, number=2,) + name_servers = proto.RepeatedField(proto.STRING, number=3,) + transfer_lock_state = proto.Field(proto.ENUM, number=4, enum="TransferLockState",) + supported_privacy = proto.RepeatedField( + proto.ENUM, number=5, enum="ContactPrivacy", + ) + yearly_price = proto.Field(proto.MESSAGE, number=6, message=money_pb2.Money,) + + +class AuthorizationCode(proto.Message): + r"""Defines an authorization code. + + Attributes: + code (str): + The Authorization Code in ASCII. It can be + used to transfer the domain to or from another + registrar. + """ + + code = proto.Field(proto.STRING, number=1,) + + +class OperationMetadata(proto.Message): + r"""Represents the metadata of the long-running operation. Output + only. + + Attributes: + create_time (google.protobuf.timestamp_pb2.Timestamp): + The time the operation was created. + end_time (google.protobuf.timestamp_pb2.Timestamp): + The time the operation finished running. + target (str): + Server-defined resource path for the target + of the operation. + verb (str): + Name of the verb executed by the operation. + status_detail (str): + Human-readable status of the operation, if + any. + api_version (str): + API version used to start the operation. + """ + + create_time = proto.Field(proto.MESSAGE, number=1, message=timestamp_pb2.Timestamp,) + end_time = proto.Field(proto.MESSAGE, number=2, message=timestamp_pb2.Timestamp,) + target = proto.Field(proto.STRING, number=3,) + verb = proto.Field(proto.STRING, number=4,) + status_detail = proto.Field(proto.STRING, number=5,) + api_version = proto.Field(proto.STRING, number=6,) + + +__all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/google/cloud/domains_v1beta1/__init__.py b/google/cloud/domains_v1beta1/__init__.py index 7e9ede1..10f2983 100644 --- a/google/cloud/domains_v1beta1/__init__.py +++ b/google/cloud/domains_v1beta1/__init__.py @@ -37,8 +37,12 @@ from .types.domains import RetrieveAuthorizationCodeRequest from .types.domains import RetrieveRegisterParametersRequest from .types.domains import RetrieveRegisterParametersResponse +from .types.domains import RetrieveTransferParametersRequest +from .types.domains import RetrieveTransferParametersResponse from .types.domains import SearchDomainsRequest from .types.domains import SearchDomainsResponse +from .types.domains import TransferDomainRequest +from .types.domains import TransferParameters from .types.domains import UpdateRegistrationRequest from .types.domains import ContactNotice from .types.domains import ContactPrivacy @@ -71,8 +75,12 @@ "RetrieveAuthorizationCodeRequest", "RetrieveRegisterParametersRequest", "RetrieveRegisterParametersResponse", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", "SearchDomainsRequest", "SearchDomainsResponse", + "TransferDomainRequest", "TransferLockState", + "TransferParameters", "UpdateRegistrationRequest", ) diff --git a/google/cloud/domains_v1beta1/gapic_metadata.json b/google/cloud/domains_v1beta1/gapic_metadata.json index dd05252..c6f9a69 100644 --- a/google/cloud/domains_v1beta1/gapic_metadata.json +++ b/google/cloud/domains_v1beta1/gapic_metadata.json @@ -65,11 +65,21 @@ "retrieve_register_parameters" ] }, + "RetrieveTransferParameters": { + "methods": [ + "retrieve_transfer_parameters" + ] + }, "SearchDomains": { "methods": [ "search_domains" ] }, + "TransferDomain": { + "methods": [ + "transfer_domain" + ] + }, "UpdateRegistration": { "methods": [ "update_registration" @@ -135,11 +145,21 @@ "retrieve_register_parameters" ] }, + "RetrieveTransferParameters": { + "methods": [ + "retrieve_transfer_parameters" + ] + }, "SearchDomains": { "methods": [ "search_domains" ] }, + "TransferDomain": { + "methods": [ + "transfer_domain" + ] + }, "UpdateRegistration": { "methods": [ "update_registration" diff --git a/google/cloud/domains_v1beta1/services/domains/async_client.py b/google/cloud/domains_v1beta1/services/domains/async_client.py index 05b829c..4deada9 100644 --- a/google/cloud/domains_v1beta1/services/domains/async_client.py +++ b/google/cloud/domains_v1beta1/services/domains/async_client.py @@ -394,6 +394,9 @@ async def register_domain( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -402,6 +405,15 @@ async def register_domain( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -452,6 +464,256 @@ async def register_domain( # Done; return the response. return response + async def retrieve_transfer_parameters( + self, + request: domains.RetrieveTransferParametersRequest = None, + *, + location: str = None, + domain_name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.RetrieveTransferParametersResponse: + r"""Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Args: + request (:class:`google.cloud.domains_v1beta1.types.RetrieveTransferParametersRequest`): + The request object. Request for the + `RetrieveTransferParameters` method. + location (:class:`str`): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + domain_name (:class:`str`): + Required. The domain name. Unicode + domain names must be expressed in + Punycode format. + + This corresponds to the ``domain_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.domains_v1beta1.types.RetrieveTransferParametersResponse: + Response for the RetrieveTransferParameters method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, domain_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 = domains.RetrieveTransferParametersRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if domain_name is not None: + request.domain_name = domain_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.retrieve_transfer_parameters, + 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((("location", request.location),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + async def transfer_domain( + self, + request: domains.TransferDomainRequest = None, + *, + parent: str = None, + registration: domains.Registration = None, + yearly_price: money_pb2.Money = None, + authorization_code: domains.AuthorizationCode = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation_async.AsyncOperation: + r"""Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Args: + request (:class:`google.cloud.domains_v1beta1.types.TransferDomainRequest`): + The request object. Request for the `TransferDomain` + method. + parent (:class:`str`): + Required. The parent resource of the ``Registration``. + Must be in the format ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + registration (:class:`google.cloud.domains_v1beta1.types.Registration`): + Required. The complete ``Registration`` resource to be + created. + + You can leave ``registration.dns_settings`` unset to + import the domain's current DNS configuration from its + current registrar. Use this option only if you are sure + that the domain's current DNS service does not cease + upon transfer, as is often the case for DNS services + provided for free by the registrar. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + yearly_price (:class:`google.type.money_pb2.Money`): + Required. Acknowledgement of the price to transfer or + renew the domain for one year. Call + ``RetrieveTransferParameters`` to obtain the price, + which you must acknowledge. + + This corresponds to the ``yearly_price`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + authorization_code (:class:`google.cloud.domains_v1beta1.types.AuthorizationCode`): + The domain's transfer authorization + code. You can obtain this from the + domain's current registrar. + + This corresponds to the ``authorization_code`` 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.api_core.operation_async.AsyncOperation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any( + [parent, registration, yearly_price, authorization_code] + ) + 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 = domains.TransferDomainRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if registration is not None: + request.registration = registration + if yearly_price is not None: + request.yearly_price = yearly_price + if authorization_code is not None: + request.authorization_code = authorization_code + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = gapic_v1.method_async.wrap_method( + self._client._transport.transfer_domain, + 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((("parent", request.parent),)), + ) + + # Send the request. + response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation_async.from_gapic( + response, + self._client._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + async def list_registrations( self, request: domains.ListRegistrationsRequest = None, @@ -565,6 +827,9 @@ async def get_registration( The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -573,6 +838,15 @@ async def get_registration( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -643,8 +917,8 @@ async def update_registration( update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`): Required. The field mask describing which fields to update as a comma-separated list. For example, if only - the labels are being updated, the ``update_mask`` would - be ``"labels"``. + the labels are being updated, the ``update_mask`` is + ``"labels"``. This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -662,6 +936,9 @@ async def update_registration( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -670,6 +947,15 @@ async def update_registration( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -754,7 +1040,7 @@ async def configure_management_settings( Required. The field mask describing which fields to update as a comma-separated list. For example, if only the transfer lock is being updated, the ``update_mask`` - would be ``"transfer_lock_state"``. + is ``"transfer_lock_state"``. This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -772,6 +1058,9 @@ async def configure_management_settings( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -780,6 +1069,15 @@ async def configure_management_settings( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -866,14 +1164,14 @@ async def configure_dns_settings( Required. The field mask describing which fields to update as a comma-separated list. For example, if only the name servers are being updated for an existing - Custom DNS configuration, the ``update_mask`` would be + Custom DNS configuration, the ``update_mask`` is ``"custom_dns.name_servers"``. When changing the DNS provider from one type to another, pass the new provider's field name as part of the field mask. For example, when changing from a Google Domains DNS configuration to a Custom DNS configuration, the - ``update_mask`` would be ``"custom_dns"``. // + ``update_mask`` is ``"custom_dns"``. // This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -891,6 +1189,9 @@ async def configure_dns_settings( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -899,6 +1200,15 @@ async def configure_dns_settings( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -986,7 +1296,7 @@ async def configure_contact_settings( Required. The field mask describing which fields to update as a comma-separated list. For example, if only the registrant contact is being updated, the - ``update_mask`` would be ``"registrant_contact"``. + ``update_mask`` is ``"registrant_contact"``. This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -1004,6 +1314,9 @@ async def configure_contact_settings( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -1012,6 +1325,15 @@ async def configure_contact_settings( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -1073,20 +1395,16 @@ async def export_registration( timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> operation_async.AsyncOperation: - r"""Exports a ``Registration`` that you no longer want to use with - Cloud Domains. You can continue to use the domain in `Google - Domains `__ until it expires. - - If the export is successful: + r"""Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. - - The resource's ``state`` becomes ``EXPORTED``, meaning that - it is no longer managed by Cloud Domains - - Because individual users can own domains in Google Domains, - the calling user becomes the domain's sole owner. Permissions - for the domain are subsequently managed in Google Domains. - - Without further action, the domain does not renew - automatically. The new owner can set up billing in Google - Domains to renew the domain if needed. + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Args: request (:class:`google.cloud.domains_v1beta1.types.ExportRegistrationRequest`): @@ -1112,6 +1430,9 @@ async def export_registration( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -1120,6 +1441,15 @@ async def export_registration( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -1177,11 +1507,26 @@ async def delete_registration( ) -> operation_async.AsyncOperation: r"""Deletes a ``Registration`` resource. - This method only works on resources in one of the following - states: + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: - ``state`` is ``EXPORTED`` with ``expire_time`` in the past - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Args: request (:class:`google.cloud.domains_v1beta1.types.DeleteRegistrationRequest`): diff --git a/google/cloud/domains_v1beta1/services/domains/client.py b/google/cloud/domains_v1beta1/services/domains/client.py index dc9516b..182e94e 100644 --- a/google/cloud/domains_v1beta1/services/domains/client.py +++ b/google/cloud/domains_v1beta1/services/domains/client.py @@ -588,6 +588,9 @@ def register_domain( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -596,6 +599,15 @@ def register_domain( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -646,6 +658,258 @@ def register_domain( # Done; return the response. return response + def retrieve_transfer_parameters( + self, + request: Union[domains.RetrieveTransferParametersRequest, dict] = None, + *, + location: str = None, + domain_name: str = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> domains.RetrieveTransferParametersResponse: + r"""Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Args: + request (Union[google.cloud.domains_v1beta1.types.RetrieveTransferParametersRequest, dict]): + The request object. Request for the + `RetrieveTransferParameters` method. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + + This corresponds to the ``location`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + domain_name (str): + Required. The domain name. Unicode + domain names must be expressed in + Punycode format. + + This corresponds to the ``domain_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.domains_v1beta1.types.RetrieveTransferParametersResponse: + Response for the RetrieveTransferParameters method. + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any([location, domain_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 domains.RetrieveTransferParametersRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.RetrieveTransferParametersRequest): + request = domains.RetrieveTransferParametersRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if location is not None: + request.location = location + if domain_name is not None: + request.domain_name = domain_name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[ + self._transport.retrieve_transfer_parameters + ] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("location", request.location),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Done; return the response. + return response + + def transfer_domain( + self, + request: Union[domains.TransferDomainRequest, dict] = None, + *, + parent: str = None, + registration: domains.Registration = None, + yearly_price: money_pb2.Money = None, + authorization_code: domains.AuthorizationCode = None, + retry: retries.Retry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operation.Operation: + r"""Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Args: + request (Union[google.cloud.domains_v1beta1.types.TransferDomainRequest, dict]): + The request object. Request for the `TransferDomain` + method. + parent (str): + Required. The parent resource of the ``Registration``. + Must be in the format ``projects/*/locations/*``. + + This corresponds to the ``parent`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + registration (google.cloud.domains_v1beta1.types.Registration): + Required. The complete ``Registration`` resource to be + created. + + You can leave ``registration.dns_settings`` unset to + import the domain's current DNS configuration from its + current registrar. Use this option only if you are sure + that the domain's current DNS service does not cease + upon transfer, as is often the case for DNS services + provided for free by the registrar. + + This corresponds to the ``registration`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + yearly_price (google.type.money_pb2.Money): + Required. Acknowledgement of the price to transfer or + renew the domain for one year. Call + ``RetrieveTransferParameters`` to obtain the price, + which you must acknowledge. + + This corresponds to the ``yearly_price`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + authorization_code (google.cloud.domains_v1beta1.types.AuthorizationCode): + The domain's transfer authorization + code. You can obtain this from the + domain's current registrar. + + This corresponds to the ``authorization_code`` 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.api_core.operation.Operation: + An object representing a long-running operation. + + The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name + registrations. + + There are several ways to create a new Registration + resource: + + To create a new Registration resource, find a + suitable domain name by calling the SearchDomains + method with a query to see available domain name + options. After choosing a name, call + RetrieveRegisterParameters to ensure availability and + obtain information like pricing, which is needed to + build a call to RegisterDomain. + + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + + """ + # Create or coerce a protobuf request object. + # Sanity check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + has_flattened_params = any( + [parent, registration, yearly_price, authorization_code] + ) + 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 domains.TransferDomainRequest. + # There's no risk of modifying the input as we've already verified + # there are no flattened fields. + if not isinstance(request, domains.TransferDomainRequest): + request = domains.TransferDomainRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if parent is not None: + request.parent = parent + if registration is not None: + request.registration = registration + if yearly_price is not None: + request.yearly_price = yearly_price + if authorization_code is not None: + request.authorization_code = authorization_code + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.transfer_domain] + + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)), + ) + + # Send the request. + response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + + # Wrap the response in an operation future. + response = operation.from_gapic( + response, + self._transport.operations_client, + domains.Registration, + metadata_type=domains.OperationMetadata, + ) + + # Done; return the response. + return response + def list_registrations( self, request: Union[domains.ListRegistrationsRequest, dict] = None, @@ -759,6 +1023,9 @@ def get_registration( The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -767,6 +1034,15 @@ def get_registration( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -837,8 +1113,8 @@ def update_registration( update_mask (google.protobuf.field_mask_pb2.FieldMask): Required. The field mask describing which fields to update as a comma-separated list. For example, if only - the labels are being updated, the ``update_mask`` would - be ``"labels"``. + the labels are being updated, the ``update_mask`` is + ``"labels"``. This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -856,6 +1132,9 @@ def update_registration( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -864,6 +1143,15 @@ def update_registration( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -948,7 +1236,7 @@ def configure_management_settings( Required. The field mask describing which fields to update as a comma-separated list. For example, if only the transfer lock is being updated, the ``update_mask`` - would be ``"transfer_lock_state"``. + is ``"transfer_lock_state"``. This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -966,6 +1254,9 @@ def configure_management_settings( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -974,6 +1265,15 @@ def configure_management_settings( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -1062,14 +1362,14 @@ def configure_dns_settings( Required. The field mask describing which fields to update as a comma-separated list. For example, if only the name servers are being updated for an existing - Custom DNS configuration, the ``update_mask`` would be + Custom DNS configuration, the ``update_mask`` is ``"custom_dns.name_servers"``. When changing the DNS provider from one type to another, pass the new provider's field name as part of the field mask. For example, when changing from a Google Domains DNS configuration to a Custom DNS configuration, the - ``update_mask`` would be ``"custom_dns"``. // + ``update_mask`` is ``"custom_dns"``. // This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -1087,6 +1387,9 @@ def configure_dns_settings( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -1095,6 +1398,15 @@ def configure_dns_settings( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -1182,7 +1494,7 @@ def configure_contact_settings( Required. The field mask describing which fields to update as a comma-separated list. For example, if only the registrant contact is being updated, the - ``update_mask`` would be ``"registrant_contact"``. + ``update_mask`` is ``"registrant_contact"``. This corresponds to the ``update_mask`` field on the ``request`` instance; if ``request`` is provided, this @@ -1200,6 +1512,9 @@ def configure_contact_settings( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -1208,6 +1523,15 @@ def configure_contact_settings( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -1271,20 +1595,16 @@ def export_registration( timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> operation.Operation: - r"""Exports a ``Registration`` that you no longer want to use with - Cloud Domains. You can continue to use the domain in `Google - Domains `__ until it expires. - - If the export is successful: + r"""Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. - - The resource's ``state`` becomes ``EXPORTED``, meaning that - it is no longer managed by Cloud Domains - - Because individual users can own domains in Google Domains, - the calling user becomes the domain's sole owner. Permissions - for the domain are subsequently managed in Google Domains. - - Without further action, the domain does not renew - automatically. The new owner can set up billing in Google - Domains to renew the domain if needed. + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Args: request (Union[google.cloud.domains_v1beta1.types.ExportRegistrationRequest, dict]): @@ -1310,6 +1630,9 @@ def export_registration( The result type for the operation will be :class:`google.cloud.domains_v1beta1.types.Registration` The Registration resource facilitates managing and configuring domain name registrations. + There are several ways to create a new Registration + resource: + To create a new Registration resource, find a suitable domain name by calling the SearchDomains method with a query to see available domain name @@ -1318,6 +1641,15 @@ def export_registration( obtain information like pricing, which is needed to build a call to RegisterDomain. + Another way to create a new Registration is to + transfer an existing domain from another registrar. + First, go to the current registrar to unlock the + domain for transfer and retrieve the domain's + transfer authorization code. Then call + RetrieveTransferParameters to confirm that the domain + is unlocked and to get values needed to build a call + to TransferDomain. + """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have @@ -1375,11 +1707,26 @@ def delete_registration( ) -> operation.Operation: r"""Deletes a ``Registration`` resource. - This method only works on resources in one of the following - states: + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: - ``state`` is ``EXPORTED`` with ``expire_time`` in the past - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Args: request (Union[google.cloud.domains_v1beta1.types.DeleteRegistrationRequest, dict]): diff --git a/google/cloud/domains_v1beta1/services/domains/transports/base.py b/google/cloud/domains_v1beta1/services/domains/transports/base.py index 561c774..f95e6f9 100644 --- a/google/cloud/domains_v1beta1/services/domains/transports/base.py +++ b/google/cloud/domains_v1beta1/services/domains/transports/base.py @@ -165,6 +165,14 @@ def _prep_wrapped_messages(self, client_info): self.register_domain: gapic_v1.method.wrap_method( self.register_domain, default_timeout=None, client_info=client_info, ), + self.retrieve_transfer_parameters: gapic_v1.method.wrap_method( + self.retrieve_transfer_parameters, + default_timeout=None, + client_info=client_info, + ), + self.transfer_domain: gapic_v1.method.wrap_method( + self.transfer_domain, default_timeout=None, client_info=client_info, + ), self.list_registrations: gapic_v1.method.wrap_method( self.list_registrations, default_timeout=None, client_info=client_info, ), @@ -251,6 +259,27 @@ def register_domain( ]: raise NotImplementedError() + @property + def retrieve_transfer_parameters( + self, + ) -> Callable[ + [domains.RetrieveTransferParametersRequest], + Union[ + domains.RetrieveTransferParametersResponse, + Awaitable[domains.RetrieveTransferParametersResponse], + ], + ]: + raise NotImplementedError() + + @property + def transfer_domain( + self, + ) -> Callable[ + [domains.TransferDomainRequest], + Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], + ]: + raise NotImplementedError() + @property def list_registrations( self, diff --git a/google/cloud/domains_v1beta1/services/domains/transports/grpc.py b/google/cloud/domains_v1beta1/services/domains/transports/grpc.py index 2e52c37..a7b69f1 100644 --- a/google/cloud/domains_v1beta1/services/domains/transports/grpc.py +++ b/google/cloud/domains_v1beta1/services/domains/transports/grpc.py @@ -344,6 +344,88 @@ def register_domain( ) return self._stubs["register_domain"] + @property + def retrieve_transfer_parameters( + self, + ) -> Callable[ + [domains.RetrieveTransferParametersRequest], + domains.RetrieveTransferParametersResponse, + ]: + r"""Return a callable for the retrieve transfer parameters method over gRPC. + + Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Returns: + Callable[[~.RetrieveTransferParametersRequest], + ~.RetrieveTransferParametersResponse]: + 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 "retrieve_transfer_parameters" not in self._stubs: + self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1beta1.Domains/RetrieveTransferParameters", + request_serializer=domains.RetrieveTransferParametersRequest.serialize, + response_deserializer=domains.RetrieveTransferParametersResponse.deserialize, + ) + return self._stubs["retrieve_transfer_parameters"] + + @property + def transfer_domain( + self, + ) -> Callable[[domains.TransferDomainRequest], operations_pb2.Operation]: + r"""Return a callable for the transfer domain method over gRPC. + + Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Returns: + Callable[[~.TransferDomainRequest], + ~.Operation]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "transfer_domain" not in self._stubs: + self._stubs["transfer_domain"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1beta1.Domains/TransferDomain", + request_serializer=domains.TransferDomainRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["transfer_domain"] + @property def list_registrations( self, @@ -521,20 +603,16 @@ def export_registration( ) -> Callable[[domains.ExportRegistrationRequest], operations_pb2.Operation]: r"""Return a callable for the export registration method over gRPC. - Exports a ``Registration`` that you no longer want to use with - Cloud Domains. You can continue to use the domain in `Google - Domains `__ until it expires. + Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. - If the export is successful: - - - The resource's ``state`` becomes ``EXPORTED``, meaning that - it is no longer managed by Cloud Domains - - Because individual users can own domains in Google Domains, - the calling user becomes the domain's sole owner. Permissions - for the domain are subsequently managed in Google Domains. - - Without further action, the domain does not renew - automatically. The new owner can set up billing in Google - Domains to renew the domain if needed. + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Returns: Callable[[~.ExportRegistrationRequest], @@ -562,11 +640,26 @@ def delete_registration( Deletes a ``Registration`` resource. - This method only works on resources in one of the following - states: + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: - ``state`` is ``EXPORTED`` with ``expire_time`` in the past - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Returns: Callable[[~.DeleteRegistrationRequest], diff --git a/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py b/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py index 097612b..dc5afa2 100644 --- a/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py +++ b/google/cloud/domains_v1beta1/services/domains/transports/grpc_asyncio.py @@ -351,6 +351,88 @@ def register_domain( ) return self._stubs["register_domain"] + @property + def retrieve_transfer_parameters( + self, + ) -> Callable[ + [domains.RetrieveTransferParametersRequest], + Awaitable[domains.RetrieveTransferParametersResponse], + ]: + r"""Return a callable for the retrieve transfer parameters method over gRPC. + + Gets parameters needed to transfer a domain name from another + registrar to Cloud Domains. For domains managed by Google + Domains, transferring to Cloud Domains is not supported. + + Use the returned values to call ``TransferDomain``. + + Returns: + Callable[[~.RetrieveTransferParametersRequest], + Awaitable[~.RetrieveTransferParametersResponse]]: + 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 "retrieve_transfer_parameters" not in self._stubs: + self._stubs["retrieve_transfer_parameters"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1beta1.Domains/RetrieveTransferParameters", + request_serializer=domains.RetrieveTransferParametersRequest.serialize, + response_deserializer=domains.RetrieveTransferParametersResponse.deserialize, + ) + return self._stubs["retrieve_transfer_parameters"] + + @property + def transfer_domain( + self, + ) -> Callable[[domains.TransferDomainRequest], Awaitable[operations_pb2.Operation]]: + r"""Return a callable for the transfer domain method over gRPC. + + Transfers a domain name from another registrar to Cloud Domains. + For domains managed by Google Domains, transferring to Cloud + Domains is not supported. + + Before calling this method, go to the domain's current registrar + to unlock the domain for transfer and retrieve the domain's + transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to this + method. + + A successful call creates a ``Registration`` resource in state + ``TRANSFER_PENDING``. It can take several days to complete the + transfer process. The registrant can often speed up this process + by approving the transfer through the current registrar, either + by clicking a link in an email from the registrar or by visiting + the registrar's website. + + A few minutes after transfer approval, the resource transitions + to state ``ACTIVE``, indicating that the transfer was + successful. If the transfer is rejected or the request expires + without being approved, the resource can end up in state + ``TRANSFER_FAILED``. If transfer fails, you can safely delete + the resource and retry the transfer. + + Returns: + Callable[[~.TransferDomainRequest], + Awaitable[~.Operation]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "transfer_domain" not in self._stubs: + self._stubs["transfer_domain"] = self.grpc_channel.unary_unary( + "/google.cloud.domains.v1beta1.Domains/TransferDomain", + request_serializer=domains.TransferDomainRequest.serialize, + response_deserializer=operations_pb2.Operation.FromString, + ) + return self._stubs["transfer_domain"] + @property def list_registrations( self, @@ -537,20 +619,16 @@ def export_registration( ]: r"""Return a callable for the export registration method over gRPC. - Exports a ``Registration`` that you no longer want to use with - Cloud Domains. You can continue to use the domain in `Google - Domains `__ until it expires. + Exports a ``Registration`` resource, such that it is no longer + managed by Cloud Domains. - If the export is successful: - - - The resource's ``state`` becomes ``EXPORTED``, meaning that - it is no longer managed by Cloud Domains - - Because individual users can own domains in Google Domains, - the calling user becomes the domain's sole owner. Permissions - for the domain are subsequently managed in Google Domains. - - Without further action, the domain does not renew - automatically. The new owner can set up billing in Google - Domains to renew the domain if needed. + When an active domain is successfully exported, you can continue + to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Returns: Callable[[~.ExportRegistrationRequest], @@ -580,11 +658,26 @@ def delete_registration( Deletes a ``Registration`` resource. - This method only works on resources in one of the following - states: + This method works on any ``Registration`` resource using + `Subscription or Commitment + billing `__, provided that the + resource was created at least 1 day in the past. + + For ``Registration`` resources using `Monthly + billing `__, this method works + if: - ``state`` is ``EXPORTED`` with ``expire_time`` in the past - ``state`` is ``REGISTRATION_FAILED`` + - ``state`` is ``TRANSFER_FAILED`` + + When an active registration is successfully deleted, you can + continue to use the domain in `Google + Domains `__ until it expires. The + calling user becomes the domain's sole owner in Google Domains, + and permissions for the domain are subsequently managed there. + The domain does not renew automatically unless the new owner + sets up billing in Google Domains. Returns: Callable[[~.DeleteRegistrationRequest], diff --git a/google/cloud/domains_v1beta1/types/__init__.py b/google/cloud/domains_v1beta1/types/__init__.py index 73c9baa1..2ccb2c4 100644 --- a/google/cloud/domains_v1beta1/types/__init__.py +++ b/google/cloud/domains_v1beta1/types/__init__.py @@ -34,8 +34,12 @@ RetrieveAuthorizationCodeRequest, RetrieveRegisterParametersRequest, RetrieveRegisterParametersResponse, + RetrieveTransferParametersRequest, + RetrieveTransferParametersResponse, SearchDomainsRequest, SearchDomainsResponse, + TransferDomainRequest, + TransferParameters, UpdateRegistrationRequest, ContactNotice, ContactPrivacy, @@ -64,8 +68,12 @@ "RetrieveAuthorizationCodeRequest", "RetrieveRegisterParametersRequest", "RetrieveRegisterParametersResponse", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", "SearchDomainsRequest", "SearchDomainsResponse", + "TransferDomainRequest", + "TransferParameters", "UpdateRegistrationRequest", "ContactNotice", "ContactPrivacy", diff --git a/google/cloud/domains_v1beta1/types/domains.py b/google/cloud/domains_v1beta1/types/domains.py index 6f71d5e..cb78f6c 100644 --- a/google/cloud/domains_v1beta1/types/domains.py +++ b/google/cloud/domains_v1beta1/types/domains.py @@ -37,6 +37,9 @@ "RetrieveRegisterParametersRequest", "RetrieveRegisterParametersResponse", "RegisterDomainRequest", + "RetrieveTransferParametersRequest", + "RetrieveTransferParametersResponse", + "TransferDomainRequest", "ListRegistrationsRequest", "ListRegistrationsResponse", "GetRegistrationRequest", @@ -49,6 +52,7 @@ "RetrieveAuthorizationCodeRequest", "ResetAuthorizationCodeRequest", "RegisterParameters", + "TransferParameters", "AuthorizationCode", "OperationMetadata", }, @@ -94,6 +98,8 @@ class Registration(proto.Message): r"""The ``Registration`` resource facilitates managing and configuring domain name registrations. + There are several ways to create a new ``Registration`` resource: + To create a new ``Registration`` resource, find a suitable domain name by calling the ``SearchDomains`` method with a query to see available domain name options. After choosing a name, call @@ -101,6 +107,14 @@ class Registration(proto.Message): information like pricing, which is needed to build a call to ``RegisterDomain``. + Another way to create a new ``Registration`` is to transfer an + existing domain from another registrar. First, go to the current + registrar to unlock the domain for transfer and retrieve the + domain's transfer authorization code. Then call + ``RetrieveTransferParameters`` to confirm that the domain is + unlocked and to get values needed to build a call to + ``TransferDomain``. + Attributes: name (str): Output only. Name of the ``Registration`` resource, in the @@ -145,7 +159,7 @@ class Registration(proto.Message): require email confirmation by the ``registrant_contact`` before taking effect. This field is set only if there are pending updates to the ``contact_settings`` that have not - yet been confirmed. To confirm the changes, the + been confirmed. To confirm the changes, the ``registrant_contact`` must follow the instructions in the email they receive. supported_privacy (Sequence[google.cloud.domains_v1beta1.types.ContactPrivacy]): @@ -159,6 +173,8 @@ class State(proto.Enum): STATE_UNSPECIFIED = 0 REGISTRATION_PENDING = 1 REGISTRATION_FAILED = 2 + TRANSFER_PENDING = 3 + TRANSFER_FAILED = 4 ACTIVE = 6 SUSPENDED = 7 EXPORTED = 8 @@ -310,6 +326,8 @@ class Algorithm(proto.Enum): algorithms are not supported for particular domains. """ ALGORITHM_UNSPECIFIED = 0 + RSAMD5 = 1 + DH = 2 DSA = 3 ECC = 4 RSASHA1 = 5 @@ -322,6 +340,9 @@ class Algorithm(proto.Enum): ECDSAP384SHA384 = 14 ED25519 = 15 ED448 = 16 + INDIRECT = 252 + PRIVATEDNS = 253 + PRIVATEOID = 254 class DigestType(proto.Enum): r"""List of hash functions that may have been used to generate a @@ -396,9 +417,9 @@ class ContactSettings(proto.Message): number, and/or postal address can take control of the domain.* - *Warning: For new ``Registration``\ s, the registrant will - receive an email confirmation that they must complete within - 14 days to avoid domain suspension.* + *Warning: For new ``Registration``\ s, the registrant + receives an email confirmation that they must complete + within 15 days to avoid domain suspension.* admin_contact (google.cloud.domains_v1beta1.types.ContactSettings.Contact): Required. The administrative contact for the ``Registration``. @@ -510,7 +531,7 @@ class RegisterDomainRequest(proto.Message): acknowledgement. contact_notices (Sequence[google.cloud.domains_v1beta1.types.ContactNotice]): The list of contact notices that the caller acknowledges. - The notices required here depend on the values specified in + The notices needed here depend on the values specified in ``registration.contact_settings``. yearly_price (google.type.money_pb2.Money): Required. Yearly price to register or renew @@ -518,8 +539,8 @@ class RegisterDomainRequest(proto.Message): can be obtained from RetrieveRegisterParameters or SearchDomains calls. validate_only (bool): - When true, only validation will be performed, without - actually registering the domain. Follows: + When true, only validation is performed, without actually + registering the domain. Follows: https://cloud.google.com/apis/design/design_patterns#request_validation """ @@ -531,6 +552,80 @@ class RegisterDomainRequest(proto.Message): validate_only = proto.Field(proto.BOOL, number=6,) +class RetrieveTransferParametersRequest(proto.Message): + r"""Request for the ``RetrieveTransferParameters`` method. + + Attributes: + domain_name (str): + Required. The domain name. Unicode domain + names must be expressed in Punycode format. + location (str): + Required. The location. Must be in the format + ``projects/*/locations/*``. + """ + + domain_name = proto.Field(proto.STRING, number=1,) + location = proto.Field(proto.STRING, number=2,) + + +class RetrieveTransferParametersResponse(proto.Message): + r"""Response for the ``RetrieveTransferParameters`` method. + + Attributes: + transfer_parameters (google.cloud.domains_v1beta1.types.TransferParameters): + Parameters to use when calling the ``TransferDomain`` + method. + """ + + transfer_parameters = proto.Field( + proto.MESSAGE, number=1, message="TransferParameters", + ) + + +class TransferDomainRequest(proto.Message): + r"""Request for the ``TransferDomain`` method. + + Attributes: + parent (str): + Required. The parent resource of the ``Registration``. Must + be in the format ``projects/*/locations/*``. + registration (google.cloud.domains_v1beta1.types.Registration): + Required. The complete ``Registration`` resource to be + created. + + You can leave ``registration.dns_settings`` unset to import + the domain's current DNS configuration from its current + registrar. Use this option only if you are sure that the + domain's current DNS service does not cease upon transfer, + as is often the case for DNS services provided for free by + the registrar. + contact_notices (Sequence[google.cloud.domains_v1beta1.types.ContactNotice]): + The list of contact notices that you acknowledge. The + notices needed here depend on the values specified in + ``registration.contact_settings``. + yearly_price (google.type.money_pb2.Money): + Required. Acknowledgement of the price to transfer or renew + the domain for one year. Call ``RetrieveTransferParameters`` + to obtain the price, which you must acknowledge. + authorization_code (google.cloud.domains_v1beta1.types.AuthorizationCode): + The domain's transfer authorization code. You + can obtain this from the domain's current + registrar. + validate_only (bool): + Validate the request without actually + transferring the domain. + """ + + parent = proto.Field(proto.STRING, number=1,) + registration = proto.Field(proto.MESSAGE, number=2, message="Registration",) + contact_notices = proto.RepeatedField(proto.ENUM, number=3, enum="ContactNotice",) + yearly_price = proto.Field(proto.MESSAGE, number=4, message=money_pb2.Money,) + authorization_code = proto.Field( + proto.MESSAGE, number=5, message="AuthorizationCode", + ) + validate_only = proto.Field(proto.BOOL, number=6,) + + class ListRegistrationsRequest(proto.Message): r"""Request for the ``ListRegistrations`` method. @@ -616,8 +711,7 @@ class UpdateRegistrationRequest(proto.Message): update_mask (google.protobuf.field_mask_pb2.FieldMask): Required. The field mask describing which fields to update as a comma-separated list. For example, if only the labels - are being updated, the ``update_mask`` would be - ``"labels"``. + are being updated, the ``update_mask`` is ``"labels"``. """ registration = proto.Field(proto.MESSAGE, number=1, message="Registration",) @@ -639,7 +733,7 @@ class ConfigureManagementSettingsRequest(proto.Message): update_mask (google.protobuf.field_mask_pb2.FieldMask): Required. The field mask describing which fields to update as a comma-separated list. For example, if only the transfer - lock is being updated, the ``update_mask`` would be + lock is being updated, the ``update_mask`` is ``"transfer_lock_state"``. """ @@ -666,14 +760,14 @@ class ConfigureDnsSettingsRequest(proto.Message): Required. The field mask describing which fields to update as a comma-separated list. For example, if only the name servers are being updated for an existing Custom DNS - configuration, the ``update_mask`` would be + configuration, the ``update_mask`` is ``"custom_dns.name_servers"``. When changing the DNS provider from one type to another, pass the new provider's field name as part of the field mask. For example, when changing from a Google Domains DNS configuration to a Custom DNS configuration, the - ``update_mask`` would be ``"custom_dns"``. // + ``update_mask`` is ``"custom_dns"``. // validate_only (bool): Validate the request without actually updating the DNS settings. @@ -700,11 +794,11 @@ class ConfigureContactSettingsRequest(proto.Message): update_mask (google.protobuf.field_mask_pb2.FieldMask): Required. The field mask describing which fields to update as a comma-separated list. For example, if only the - registrant contact is being updated, the ``update_mask`` - would be ``"registrant_contact"``. + registrant contact is being updated, the ``update_mask`` is + ``"registrant_contact"``. contact_notices (Sequence[google.cloud.domains_v1beta1.types.ContactNotice]): The list of contact notices that the caller acknowledges. - The notices required here depend on the values specified in + The notices needed here depend on the values specified in ``contact_settings``. validate_only (bool): Validate the request without actually @@ -810,6 +904,43 @@ class Availability(proto.Enum): yearly_price = proto.Field(proto.MESSAGE, number=5, message=money_pb2.Money,) +class TransferParameters(proto.Message): + r"""Parameters required to transfer a domain from another + registrar. + + Attributes: + domain_name (str): + The domain name. Unicode domain names are + expressed in Punycode format. + current_registrar (str): + The registrar that currently manages the + domain. + name_servers (Sequence[str]): + The name servers that currently store the + configuration of the domain. + transfer_lock_state (google.cloud.domains_v1beta1.types.TransferLockState): + Indicates whether the domain is protected by a transfer + lock. For a transfer to succeed, this must show + ``UNLOCKED``. To unlock a domain, go to its current + registrar. + supported_privacy (Sequence[google.cloud.domains_v1beta1.types.ContactPrivacy]): + Contact privacy options that the domain + supports. + yearly_price (google.type.money_pb2.Money): + Price to transfer or renew the domain for one + year. + """ + + domain_name = proto.Field(proto.STRING, number=1,) + current_registrar = proto.Field(proto.STRING, number=2,) + name_servers = proto.RepeatedField(proto.STRING, number=3,) + transfer_lock_state = proto.Field(proto.ENUM, number=4, enum="TransferLockState",) + supported_privacy = proto.RepeatedField( + proto.ENUM, number=5, enum="ContactPrivacy", + ) + yearly_price = proto.Field(proto.MESSAGE, number=6, message=money_pb2.Money,) + + class AuthorizationCode(proto.Message): r"""Defines an authorization code. diff --git a/scripts/fixup_domains_v1_keywords.py b/scripts/fixup_domains_v1_keywords.py new file mode 100644 index 0000000..beb9285 --- /dev/null +++ b/scripts/fixup_domains_v1_keywords.py @@ -0,0 +1,190 @@ +#! /usr/bin/env python3 +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +import argparse +import os +import libcst as cst +import pathlib +import sys +from typing import (Any, Callable, Dict, List, Sequence, Tuple) + + +def partition( + predicate: Callable[[Any], bool], + iterator: Sequence[Any] +) -> Tuple[List[Any], List[Any]]: + """A stable, out-of-place partition.""" + results = ([], []) + + for i in iterator: + results[int(predicate(i))].append(i) + + # Returns trueList, falseList + return results[1], results[0] + + +class domainsCallTransformer(cst.CSTTransformer): + CTRL_PARAMS: Tuple[str] = ('retry', 'timeout', 'metadata') + METHOD_TO_PARAMS: Dict[str, Tuple[str]] = { + 'configure_contact_settings': ('registration', 'update_mask', 'contact_settings', 'contact_notices', 'validate_only', ), + 'configure_dns_settings': ('registration', 'update_mask', 'dns_settings', 'validate_only', ), + 'configure_management_settings': ('registration', 'update_mask', 'management_settings', ), + 'delete_registration': ('name', ), + 'export_registration': ('name', ), + 'get_registration': ('name', ), + 'list_registrations': ('parent', 'page_size', 'page_token', 'filter', ), + 'register_domain': ('parent', 'registration', 'yearly_price', 'domain_notices', 'contact_notices', 'validate_only', ), + 'reset_authorization_code': ('registration', ), + 'retrieve_authorization_code': ('registration', ), + 'retrieve_register_parameters': ('domain_name', 'location', ), + 'retrieve_transfer_parameters': ('domain_name', 'location', ), + 'search_domains': ('query', 'location', ), + 'transfer_domain': ('parent', 'registration', 'yearly_price', 'contact_notices', 'authorization_code', 'validate_only', ), + 'update_registration': ('update_mask', 'registration', ), + } + + def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.CSTNode: + try: + key = original.func.attr.value + kword_params = self.METHOD_TO_PARAMS[key] + except (AttributeError, KeyError): + # Either not a method from the API or too convoluted to be sure. + return updated + + # If the existing code is valid, keyword args come after positional args. + # Therefore, all positional args must map to the first parameters. + args, kwargs = partition(lambda a: not bool(a.keyword), updated.args) + if any(k.keyword.value == "request" for k in kwargs): + # We've already fixed this file, don't fix it again. + return updated + + kwargs, ctrl_kwargs = partition( + lambda a: a.keyword.value not in self.CTRL_PARAMS, + kwargs + ) + + args, ctrl_args = args[:len(kword_params)], args[len(kword_params):] + ctrl_kwargs.extend(cst.Arg(value=a.value, keyword=cst.Name(value=ctrl)) + for a, ctrl in zip(ctrl_args, self.CTRL_PARAMS)) + + request_arg = cst.Arg( + value=cst.Dict([ + cst.DictElement( + cst.SimpleString("'{}'".format(name)), +cst.Element(value=arg.value) + ) + # Note: the args + kwargs looks silly, but keep in mind that + # the control parameters had to be stripped out, and that + # those could have been passed positionally or by keyword. + for name, arg in zip(kword_params, args + kwargs)]), + keyword=cst.Name("request") + ) + + return updated.with_changes( + args=[request_arg] + ctrl_kwargs + ) + + +def fix_files( + in_dir: pathlib.Path, + out_dir: pathlib.Path, + *, + transformer=domainsCallTransformer(), +): + """Duplicate the input dir to the output dir, fixing file method calls. + + Preconditions: + * in_dir is a real directory + * out_dir is a real, empty directory + """ + pyfile_gen = ( + pathlib.Path(os.path.join(root, f)) + for root, _, files in os.walk(in_dir) + for f in files if os.path.splitext(f)[1] == ".py" + ) + + for fpath in pyfile_gen: + with open(fpath, 'r') as f: + src = f.read() + + # Parse the code and insert method call fixes. + tree = cst.parse_module(src) + updated = tree.visit(transformer) + + # Create the path and directory structure for the new file. + updated_path = out_dir.joinpath(fpath.relative_to(in_dir)) + updated_path.parent.mkdir(parents=True, exist_ok=True) + + # Generate the updated source file at the corresponding path. + with open(updated_path, 'w') as f: + f.write(updated.code) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser( + description="""Fix up source that uses the domains client library. + +The existing sources are NOT overwritten but are copied to output_dir with changes made. + +Note: This tool operates at a best-effort level at converting positional + parameters in client method calls to keyword based parameters. + Cases where it WILL FAIL include + A) * or ** expansion in a method call. + B) Calls via function or method alias (includes free function calls) + C) Indirect or dispatched calls (e.g. the method is looked up dynamically) + + These all constitute false negatives. The tool will also detect false + positives when an API method shares a name with another method. +""") + parser.add_argument( + '-d', + '--input-directory', + required=True, + dest='input_dir', + help='the input directory to walk for python files to fix up', + ) + parser.add_argument( + '-o', + '--output-directory', + required=True, + dest='output_dir', + help='the directory to output files fixed via un-flattening', + ) + args = parser.parse_args() + input_dir = pathlib.Path(args.input_dir) + output_dir = pathlib.Path(args.output_dir) + if not input_dir.is_dir(): + print( + f"input directory '{input_dir}' does not exist or is not a directory", + file=sys.stderr, + ) + sys.exit(-1) + + if not output_dir.is_dir(): + print( + f"output directory '{output_dir}' does not exist or is not a directory", + file=sys.stderr, + ) + sys.exit(-1) + + if os.listdir(output_dir): + print( + f"output directory '{output_dir}' is not empty", + file=sys.stderr, + ) + sys.exit(-1) + + fix_files(input_dir, output_dir) diff --git a/scripts/fixup_domains_v1beta1_keywords.py b/scripts/fixup_domains_v1beta1_keywords.py index 8f86caf..beb9285 100644 --- a/scripts/fixup_domains_v1beta1_keywords.py +++ b/scripts/fixup_domains_v1beta1_keywords.py @@ -50,7 +50,9 @@ class domainsCallTransformer(cst.CSTTransformer): 'reset_authorization_code': ('registration', ), 'retrieve_authorization_code': ('registration', ), 'retrieve_register_parameters': ('domain_name', 'location', ), + 'retrieve_transfer_parameters': ('domain_name', 'location', ), 'search_domains': ('query', 'location', ), + 'transfer_domain': ('parent', 'registration', 'yearly_price', 'contact_notices', 'authorization_code', 'validate_only', ), 'update_registration': ('update_mask', 'registration', ), } diff --git a/tests/unit/gapic/domains_v1/__init__.py b/tests/unit/gapic/domains_v1/__init__.py new file mode 100644 index 0000000..4de6597 --- /dev/null +++ b/tests/unit/gapic/domains_v1/__init__.py @@ -0,0 +1,15 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 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. +# diff --git a/tests/unit/gapic/domains_v1/test_domains.py b/tests/unit/gapic/domains_v1/test_domains.py new file mode 100644 index 0000000..02c853f --- /dev/null +++ b/tests/unit/gapic/domains_v1/test_domains.py @@ -0,0 +1,4603 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +import os +import mock +import packaging.version + +import grpc +from grpc.experimental import aio +import math +import pytest +from proto.marshal.rules.dates import DurationRule, TimestampRule + + +from google.api_core import client_options +from google.api_core import exceptions as core_exceptions +from google.api_core import future +from google.api_core import gapic_v1 +from google.api_core import grpc_helpers +from google.api_core import grpc_helpers_async +from google.api_core import operation_async # type: ignore +from google.api_core import operations_v1 +from google.api_core import path_template +from google.auth import credentials as ga_credentials +from google.auth.exceptions import MutualTLSChannelError +from google.cloud.domains_v1.services.domains import DomainsAsyncClient +from google.cloud.domains_v1.services.domains import DomainsClient +from google.cloud.domains_v1.services.domains import pagers +from google.cloud.domains_v1.services.domains import transports +from google.cloud.domains_v1.services.domains.transports.base import ( + _GOOGLE_AUTH_VERSION, +) +from google.cloud.domains_v1.types import domains +from google.longrunning import operations_pb2 +from google.oauth2 import service_account +from google.protobuf import field_mask_pb2 # type: ignore +from google.protobuf import timestamp_pb2 # type: ignore +from google.type import money_pb2 # type: ignore +from google.type import postal_address_pb2 # type: ignore +import google.auth + + +# TODO(busunkim): Once google-auth >= 1.25.0 is required transitively +# through google-api-core: +# - Delete the auth "less than" test cases +# - Delete these pytest markers (Make the "greater than or equal to" tests the default). +requires_google_auth_lt_1_25_0 = pytest.mark.skipif( + packaging.version.parse(_GOOGLE_AUTH_VERSION) >= packaging.version.parse("1.25.0"), + reason="This test requires google-auth < 1.25.0", +) +requires_google_auth_gte_1_25_0 = pytest.mark.skipif( + packaging.version.parse(_GOOGLE_AUTH_VERSION) < packaging.version.parse("1.25.0"), + reason="This test requires google-auth >= 1.25.0", +) + + +def client_cert_source_callback(): + return b"cert bytes", b"key bytes" + + +# If default endpoint is localhost, then default mtls endpoint will be the same. +# This method modifies the default endpoint so the client can produce a different +# mtls endpoint for endpoint testing purposes. +def modify_default_endpoint(client): + return ( + "foo.googleapis.com" + if ("localhost" in client.DEFAULT_ENDPOINT) + else client.DEFAULT_ENDPOINT + ) + + +def test__get_default_mtls_endpoint(): + api_endpoint = "example.googleapis.com" + api_mtls_endpoint = "example.mtls.googleapis.com" + sandbox_endpoint = "example.sandbox.googleapis.com" + sandbox_mtls_endpoint = "example.mtls.sandbox.googleapis.com" + non_googleapi = "api.example.com" + + assert DomainsClient._get_default_mtls_endpoint(None) is None + assert DomainsClient._get_default_mtls_endpoint(api_endpoint) == api_mtls_endpoint + assert ( + DomainsClient._get_default_mtls_endpoint(api_mtls_endpoint) == api_mtls_endpoint + ) + assert ( + DomainsClient._get_default_mtls_endpoint(sandbox_endpoint) + == sandbox_mtls_endpoint + ) + assert ( + DomainsClient._get_default_mtls_endpoint(sandbox_mtls_endpoint) + == sandbox_mtls_endpoint + ) + assert DomainsClient._get_default_mtls_endpoint(non_googleapi) == non_googleapi + + +@pytest.mark.parametrize("client_class", [DomainsClient, DomainsAsyncClient,]) +def test_domains_client_from_service_account_info(client_class): + creds = ga_credentials.AnonymousCredentials() + with mock.patch.object( + service_account.Credentials, "from_service_account_info" + ) as factory: + factory.return_value = creds + info = {"valid": True} + client = client_class.from_service_account_info(info) + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + assert client.transport._host == "domains.googleapis.com:443" + + +@pytest.mark.parametrize( + "transport_class,transport_name", + [ + (transports.DomainsGrpcTransport, "grpc"), + (transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"), + ], +) +def test_domains_client_service_account_always_use_jwt(transport_class, transport_name): + with mock.patch.object( + service_account.Credentials, "with_always_use_jwt_access", create=True + ) as use_jwt: + creds = service_account.Credentials(None, None, None) + transport = transport_class(credentials=creds, always_use_jwt_access=True) + use_jwt.assert_called_once_with(True) + + with mock.patch.object( + service_account.Credentials, "with_always_use_jwt_access", create=True + ) as use_jwt: + creds = service_account.Credentials(None, None, None) + transport = transport_class(credentials=creds, always_use_jwt_access=False) + use_jwt.assert_not_called() + + +@pytest.mark.parametrize("client_class", [DomainsClient, DomainsAsyncClient,]) +def test_domains_client_from_service_account_file(client_class): + creds = ga_credentials.AnonymousCredentials() + with mock.patch.object( + service_account.Credentials, "from_service_account_file" + ) as factory: + factory.return_value = creds + client = client_class.from_service_account_file("dummy/file/path.json") + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + client = client_class.from_service_account_json("dummy/file/path.json") + assert client.transport._credentials == creds + assert isinstance(client, client_class) + + assert client.transport._host == "domains.googleapis.com:443" + + +def test_domains_client_get_transport_class(): + transport = DomainsClient.get_transport_class() + available_transports = [ + transports.DomainsGrpcTransport, + ] + assert transport in available_transports + + transport = DomainsClient.get_transport_class("grpc") + assert transport == transports.DomainsGrpcTransport + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + (DomainsClient, transports.DomainsGrpcTransport, "grpc"), + (DomainsAsyncClient, transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"), + ], +) +@mock.patch.object( + DomainsClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsClient) +) +@mock.patch.object( + DomainsAsyncClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsAsyncClient) +) +def test_domains_client_client_options(client_class, transport_class, transport_name): + # Check that if channel is provided we won't create a new one. + with mock.patch.object(DomainsClient, "get_transport_class") as gtc: + transport = transport_class(credentials=ga_credentials.AnonymousCredentials()) + client = client_class(transport=transport) + gtc.assert_not_called() + + # Check that if channel is provided via str we will create a new one. + with mock.patch.object(DomainsClient, "get_transport_class") as gtc: + client = client_class(transport=transport_name) + gtc.assert_called() + + # Check the case api_endpoint is provided. + options = client_options.ClientOptions(api_endpoint="squid.clam.whelk") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host="squid.clam.whelk", + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is + # "never". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}): + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class() + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT is + # "always". + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}): + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class() + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_MTLS_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + # Check the case api_endpoint is not provided and GOOGLE_API_USE_MTLS_ENDPOINT has + # unsupported value. + with mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "Unsupported"}): + with pytest.raises(MutualTLSChannelError): + client = client_class() + + # Check the case GOOGLE_API_USE_CLIENT_CERTIFICATE has unsupported value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "Unsupported"} + ): + with pytest.raises(ValueError): + client = client_class() + + # Check the case quota_project_id is provided + options = client_options.ClientOptions(quota_project_id="octopus") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id="octopus", + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name,use_client_cert_env", + [ + (DomainsClient, transports.DomainsGrpcTransport, "grpc", "true"), + ( + DomainsAsyncClient, + transports.DomainsGrpcAsyncIOTransport, + "grpc_asyncio", + "true", + ), + (DomainsClient, transports.DomainsGrpcTransport, "grpc", "false"), + ( + DomainsAsyncClient, + transports.DomainsGrpcAsyncIOTransport, + "grpc_asyncio", + "false", + ), + ], +) +@mock.patch.object( + DomainsClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsClient) +) +@mock.patch.object( + DomainsAsyncClient, "DEFAULT_ENDPOINT", modify_default_endpoint(DomainsAsyncClient) +) +@mock.patch.dict(os.environ, {"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"}) +def test_domains_client_mtls_env_auto( + client_class, transport_class, transport_name, use_client_cert_env +): + # This tests the endpoint autoswitch behavior. Endpoint is autoswitched to the default + # mtls endpoint, if GOOGLE_API_USE_CLIENT_CERTIFICATE is "true" and client cert exists. + + # Check the case client_cert_source is provided. Whether client cert is used depends on + # GOOGLE_API_USE_CLIENT_CERTIFICATE value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + options = client_options.ClientOptions( + client_cert_source=client_cert_source_callback + ) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + + if use_client_cert_env == "false": + expected_client_cert_source = None + expected_host = client.DEFAULT_ENDPOINT + else: + expected_client_cert_source = client_cert_source_callback + expected_host = client.DEFAULT_MTLS_ENDPOINT + + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=expected_host, + scopes=None, + client_cert_source_for_mtls=expected_client_cert_source, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + # Check the case ADC client cert is provided. Whether client cert is used depends on + # GOOGLE_API_USE_CLIENT_CERTIFICATE value. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + with mock.patch.object(transport_class, "__init__") as patched: + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=True, + ): + with mock.patch( + "google.auth.transport.mtls.default_client_cert_source", + return_value=client_cert_source_callback, + ): + if use_client_cert_env == "false": + expected_host = client.DEFAULT_ENDPOINT + expected_client_cert_source = None + else: + expected_host = client.DEFAULT_MTLS_ENDPOINT + expected_client_cert_source = client_cert_source_callback + + patched.return_value = None + client = client_class() + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=expected_host, + scopes=None, + client_cert_source_for_mtls=expected_client_cert_source, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + # Check the case client_cert_source and ADC client cert are not provided. + with mock.patch.dict( + os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": use_client_cert_env} + ): + with mock.patch.object(transport_class, "__init__") as patched: + with mock.patch( + "google.auth.transport.mtls.has_default_client_cert_source", + return_value=False, + ): + patched.return_value = None + client = client_class() + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + (DomainsClient, transports.DomainsGrpcTransport, "grpc"), + (DomainsAsyncClient, transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"), + ], +) +def test_domains_client_client_options_scopes( + client_class, transport_class, transport_name +): + # Check the case scopes are provided. + options = client_options.ClientOptions(scopes=["1", "2"],) + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + patched.assert_called_once_with( + credentials=None, + credentials_file=None, + host=client.DEFAULT_ENDPOINT, + scopes=["1", "2"], + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + +@pytest.mark.parametrize( + "client_class,transport_class,transport_name", + [ + (DomainsClient, transports.DomainsGrpcTransport, "grpc"), + (DomainsAsyncClient, transports.DomainsGrpcAsyncIOTransport, "grpc_asyncio"), + ], +) +def test_domains_client_client_options_credentials_file( + client_class, transport_class, transport_name +): + # Check the case credentials file is provided. + options = client_options.ClientOptions(credentials_file="credentials.json") + with mock.patch.object(transport_class, "__init__") as patched: + patched.return_value = None + client = client_class(client_options=options) + patched.assert_called_once_with( + credentials=None, + credentials_file="credentials.json", + host=client.DEFAULT_ENDPOINT, + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + +def test_domains_client_client_options_from_dict(): + with mock.patch( + "google.cloud.domains_v1.services.domains.transports.DomainsGrpcTransport.__init__" + ) as grpc_transport: + grpc_transport.return_value = None + client = DomainsClient(client_options={"api_endpoint": "squid.clam.whelk"}) + grpc_transport.assert_called_once_with( + credentials=None, + credentials_file=None, + host="squid.clam.whelk", + scopes=None, + client_cert_source_for_mtls=None, + quota_project_id=None, + client_info=transports.base.DEFAULT_CLIENT_INFO, + always_use_jwt_access=True, + ) + + +def test_search_domains( + transport: str = "grpc", request_type=domains.SearchDomainsRequest +): + client = DomainsClient( + 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.search_domains), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = domains.SearchDomainsResponse() + response = client.search_domains(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.SearchDomainsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.SearchDomainsResponse) + + +def test_search_domains_from_dict(): + test_search_domains(request_type=dict) + + +def test_search_domains_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 = DomainsClient( + 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.search_domains), "__call__") as call: + client.search_domains() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.SearchDomainsRequest() + + +@pytest.mark.asyncio +async def test_search_domains_async( + transport: str = "grpc_asyncio", request_type=domains.SearchDomainsRequest +): + client = DomainsAsyncClient( + 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.search_domains), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.SearchDomainsResponse() + ) + response = await client.search_domains(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.SearchDomainsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.SearchDomainsResponse) + + +@pytest.mark.asyncio +async def test_search_domains_async_from_dict(): + await test_search_domains_async(request_type=dict) + + +def test_search_domains_field_headers(): + client = DomainsClient(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 = domains.SearchDomainsRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.search_domains), "__call__") as call: + call.return_value = domains.SearchDomainsResponse() + client.search_domains(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", "location=location/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_search_domains_field_headers_async(): + client = DomainsAsyncClient(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 = domains.SearchDomainsRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.search_domains), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.SearchDomainsResponse() + ) + await client.search_domains(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", "location=location/value",) in kw["metadata"] + + +def test_search_domains_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.search_domains), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = domains.SearchDomainsResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.search_domains( + location="location_value", query="query_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] + assert args[0].location == "location_value" + assert args[0].query == "query_value" + + +def test_search_domains_flattened_error(): + client = DomainsClient(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.search_domains( + domains.SearchDomainsRequest(), + location="location_value", + query="query_value", + ) + + +@pytest.mark.asyncio +async def test_search_domains_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.search_domains), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = domains.SearchDomainsResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.SearchDomainsResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.search_domains( + location="location_value", query="query_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].query == "query_value" + + +@pytest.mark.asyncio +async def test_search_domains_flattened_error_async(): + client = DomainsAsyncClient(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.search_domains( + domains.SearchDomainsRequest(), + location="location_value", + query="query_value", + ) + + +def test_retrieve_register_parameters( + transport: str = "grpc", request_type=domains.RetrieveRegisterParametersRequest +): + client = DomainsClient( + 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.retrieve_register_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveRegisterParametersResponse() + response = client.retrieve_register_parameters(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveRegisterParametersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.RetrieveRegisterParametersResponse) + + +def test_retrieve_register_parameters_from_dict(): + test_retrieve_register_parameters(request_type=dict) + + +def test_retrieve_register_parameters_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 = DomainsClient( + 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.retrieve_register_parameters), "__call__" + ) as call: + client.retrieve_register_parameters() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveRegisterParametersRequest() + + +@pytest.mark.asyncio +async def test_retrieve_register_parameters_async( + transport: str = "grpc_asyncio", + request_type=domains.RetrieveRegisterParametersRequest, +): + client = DomainsAsyncClient( + 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.retrieve_register_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveRegisterParametersResponse() + ) + response = await client.retrieve_register_parameters(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveRegisterParametersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.RetrieveRegisterParametersResponse) + + +@pytest.mark.asyncio +async def test_retrieve_register_parameters_async_from_dict(): + await test_retrieve_register_parameters_async(request_type=dict) + + +def test_retrieve_register_parameters_field_headers(): + client = DomainsClient(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 = domains.RetrieveRegisterParametersRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_register_parameters), "__call__" + ) as call: + call.return_value = domains.RetrieveRegisterParametersResponse() + client.retrieve_register_parameters(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", "location=location/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_retrieve_register_parameters_field_headers_async(): + client = DomainsAsyncClient(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 = domains.RetrieveRegisterParametersRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_register_parameters), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveRegisterParametersResponse() + ) + await client.retrieve_register_parameters(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", "location=location/value",) in kw["metadata"] + + +def test_retrieve_register_parameters_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_register_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveRegisterParametersResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.retrieve_register_parameters( + location="location_value", domain_name="domain_name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].domain_name == "domain_name_value" + + +def test_retrieve_register_parameters_flattened_error(): + client = DomainsClient(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.retrieve_register_parameters( + domains.RetrieveRegisterParametersRequest(), + location="location_value", + domain_name="domain_name_value", + ) + + +@pytest.mark.asyncio +async def test_retrieve_register_parameters_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_register_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveRegisterParametersResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveRegisterParametersResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.retrieve_register_parameters( + location="location_value", domain_name="domain_name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].domain_name == "domain_name_value" + + +@pytest.mark.asyncio +async def test_retrieve_register_parameters_flattened_error_async(): + client = DomainsAsyncClient(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.retrieve_register_parameters( + domains.RetrieveRegisterParametersRequest(), + location="location_value", + domain_name="domain_name_value", + ) + + +def test_register_domain( + transport: str = "grpc", request_type=domains.RegisterDomainRequest +): + client = DomainsClient( + 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.register_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.register_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RegisterDomainRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_register_domain_from_dict(): + test_register_domain(request_type=dict) + + +def test_register_domain_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 = DomainsClient( + 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.register_domain), "__call__") as call: + client.register_domain() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RegisterDomainRequest() + + +@pytest.mark.asyncio +async def test_register_domain_async( + transport: str = "grpc_asyncio", request_type=domains.RegisterDomainRequest +): + client = DomainsAsyncClient( + 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.register_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.register_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RegisterDomainRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_register_domain_async_from_dict(): + await test_register_domain_async(request_type=dict) + + +def test_register_domain_field_headers(): + client = DomainsClient(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 = domains.RegisterDomainRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.register_domain), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.register_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_register_domain_field_headers_async(): + client = DomainsAsyncClient(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 = domains.RegisterDomainRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.register_domain), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.register_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +def test_register_domain_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.register_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.register_domain( + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_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] + assert args[0].parent == "parent_value" + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].yearly_price == money_pb2.Money( + currency_code="currency_code_value" + ) + + +def test_register_domain_flattened_error(): + client = DomainsClient(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.register_domain( + domains.RegisterDomainRequest(), + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + ) + + +@pytest.mark.asyncio +async def test_register_domain_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.register_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.register_domain( + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].parent == "parent_value" + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].yearly_price == money_pb2.Money( + currency_code="currency_code_value" + ) + + +@pytest.mark.asyncio +async def test_register_domain_flattened_error_async(): + client = DomainsAsyncClient(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.register_domain( + domains.RegisterDomainRequest(), + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + ) + + +def test_retrieve_transfer_parameters( + transport: str = "grpc", request_type=domains.RetrieveTransferParametersRequest +): + client = DomainsClient( + 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.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveTransferParametersResponse() + response = client.retrieve_transfer_parameters(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveTransferParametersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.RetrieveTransferParametersResponse) + + +def test_retrieve_transfer_parameters_from_dict(): + test_retrieve_transfer_parameters(request_type=dict) + + +def test_retrieve_transfer_parameters_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 = DomainsClient( + 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.retrieve_transfer_parameters), "__call__" + ) as call: + client.retrieve_transfer_parameters() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveTransferParametersRequest() + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_async( + transport: str = "grpc_asyncio", + request_type=domains.RetrieveTransferParametersRequest, +): + client = DomainsAsyncClient( + 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.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveTransferParametersResponse() + ) + response = await client.retrieve_transfer_parameters(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveTransferParametersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.RetrieveTransferParametersResponse) + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_async_from_dict(): + await test_retrieve_transfer_parameters_async(request_type=dict) + + +def test_retrieve_transfer_parameters_field_headers(): + client = DomainsClient(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 = domains.RetrieveTransferParametersRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + call.return_value = domains.RetrieveTransferParametersResponse() + client.retrieve_transfer_parameters(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", "location=location/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_field_headers_async(): + client = DomainsAsyncClient(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 = domains.RetrieveTransferParametersRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveTransferParametersResponse() + ) + await client.retrieve_transfer_parameters(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", "location=location/value",) in kw["metadata"] + + +def test_retrieve_transfer_parameters_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveTransferParametersResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.retrieve_transfer_parameters( + location="location_value", domain_name="domain_name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].domain_name == "domain_name_value" + + +def test_retrieve_transfer_parameters_flattened_error(): + client = DomainsClient(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.retrieve_transfer_parameters( + domains.RetrieveTransferParametersRequest(), + location="location_value", + domain_name="domain_name_value", + ) + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveTransferParametersResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveTransferParametersResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.retrieve_transfer_parameters( + location="location_value", domain_name="domain_name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].domain_name == "domain_name_value" + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_flattened_error_async(): + client = DomainsAsyncClient(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.retrieve_transfer_parameters( + domains.RetrieveTransferParametersRequest(), + location="location_value", + domain_name="domain_name_value", + ) + + +def test_transfer_domain( + transport: str = "grpc", request_type=domains.TransferDomainRequest +): + client = DomainsClient( + 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.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.TransferDomainRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_transfer_domain_from_dict(): + test_transfer_domain(request_type=dict) + + +def test_transfer_domain_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 = DomainsClient( + 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.transfer_domain), "__call__") as call: + client.transfer_domain() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.TransferDomainRequest() + + +@pytest.mark.asyncio +async def test_transfer_domain_async( + transport: str = "grpc_asyncio", request_type=domains.TransferDomainRequest +): + client = DomainsAsyncClient( + 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.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.TransferDomainRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_transfer_domain_async_from_dict(): + await test_transfer_domain_async(request_type=dict) + + +def test_transfer_domain_field_headers(): + client = DomainsClient(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 = domains.TransferDomainRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_transfer_domain_field_headers_async(): + client = DomainsAsyncClient(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 = domains.TransferDomainRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +def test_transfer_domain_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.transfer_domain( + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_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] + assert args[0].parent == "parent_value" + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].yearly_price == money_pb2.Money( + currency_code="currency_code_value" + ) + assert args[0].authorization_code == domains.AuthorizationCode( + code="code_value" + ) + + +def test_transfer_domain_flattened_error(): + client = DomainsClient(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.transfer_domain( + domains.TransferDomainRequest(), + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_value"), + ) + + +@pytest.mark.asyncio +async def test_transfer_domain_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.transfer_domain( + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_value"), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].parent == "parent_value" + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].yearly_price == money_pb2.Money( + currency_code="currency_code_value" + ) + assert args[0].authorization_code == domains.AuthorizationCode( + code="code_value" + ) + + +@pytest.mark.asyncio +async def test_transfer_domain_flattened_error_async(): + client = DomainsAsyncClient(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.transfer_domain( + domains.TransferDomainRequest(), + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_value"), + ) + + +def test_list_registrations( + transport: str = "grpc", request_type=domains.ListRegistrationsRequest +): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.ListRegistrationsResponse( + next_page_token="next_page_token_value", + ) + response = client.list_registrations(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ListRegistrationsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListRegistrationsPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_registrations_from_dict(): + test_list_registrations(request_type=dict) + + +def test_list_registrations_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 = DomainsClient( + 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.list_registrations), "__call__" + ) as call: + client.list_registrations() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ListRegistrationsRequest() + + +@pytest.mark.asyncio +async def test_list_registrations_async( + transport: str = "grpc_asyncio", request_type=domains.ListRegistrationsRequest +): + client = DomainsAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.ListRegistrationsResponse(next_page_token="next_page_token_value",) + ) + response = await client.list_registrations(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ListRegistrationsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListRegistrationsAsyncPager) + assert response.next_page_token == "next_page_token_value" + + +@pytest.mark.asyncio +async def test_list_registrations_async_from_dict(): + await test_list_registrations_async(request_type=dict) + + +def test_list_registrations_field_headers(): + client = DomainsClient(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 = domains.ListRegistrationsRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + call.return_value = domains.ListRegistrationsResponse() + client.list_registrations(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_registrations_field_headers_async(): + client = DomainsAsyncClient(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 = domains.ListRegistrationsRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.ListRegistrationsResponse() + ) + await client.list_registrations(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +def test_list_registrations_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.ListRegistrationsResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.list_registrations(parent="parent_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].parent == "parent_value" + + +def test_list_registrations_flattened_error(): + client = DomainsClient(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_registrations( + domains.ListRegistrationsRequest(), parent="parent_value", + ) + + +@pytest.mark.asyncio +async def test_list_registrations_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.ListRegistrationsResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.ListRegistrationsResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.list_registrations(parent="parent_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].parent == "parent_value" + + +@pytest.mark.asyncio +async def test_list_registrations_flattened_error_async(): + client = DomainsAsyncClient(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.list_registrations( + domains.ListRegistrationsRequest(), parent="parent_value", + ) + + +def test_list_registrations_pager(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials,) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + domains.ListRegistrationsResponse( + registrations=[ + domains.Registration(), + domains.Registration(), + domains.Registration(), + ], + next_page_token="abc", + ), + domains.ListRegistrationsResponse(registrations=[], next_page_token="def",), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(),], next_page_token="ghi", + ), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(), domains.Registration(),], + ), + RuntimeError, + ) + + metadata = () + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata((("parent", ""),)), + ) + pager = client.list_registrations(request={}) + + assert pager._metadata == metadata + + results = [i for i in pager] + assert len(results) == 6 + assert all(isinstance(i, domains.Registration) for i in results) + + +def test_list_registrations_pages(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials,) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), "__call__" + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + domains.ListRegistrationsResponse( + registrations=[ + domains.Registration(), + domains.Registration(), + domains.Registration(), + ], + next_page_token="abc", + ), + domains.ListRegistrationsResponse(registrations=[], next_page_token="def",), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(),], next_page_token="ghi", + ), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(), domains.Registration(),], + ), + RuntimeError, + ) + pages = list(client.list_registrations(request={}).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.asyncio +async def test_list_registrations_async_pager(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials,) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + domains.ListRegistrationsResponse( + registrations=[ + domains.Registration(), + domains.Registration(), + domains.Registration(), + ], + next_page_token="abc", + ), + domains.ListRegistrationsResponse(registrations=[], next_page_token="def",), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(),], next_page_token="ghi", + ), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(), domains.Registration(),], + ), + RuntimeError, + ) + async_pager = await client.list_registrations(request={},) + assert async_pager.next_page_token == "abc" + responses = [] + async for response in async_pager: + responses.append(response) + + assert len(responses) == 6 + assert all(isinstance(i, domains.Registration) for i in responses) + + +@pytest.mark.asyncio +async def test_list_registrations_async_pages(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials,) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_registrations), + "__call__", + new_callable=mock.AsyncMock, + ) as call: + # Set the response to a series of pages. + call.side_effect = ( + domains.ListRegistrationsResponse( + registrations=[ + domains.Registration(), + domains.Registration(), + domains.Registration(), + ], + next_page_token="abc", + ), + domains.ListRegistrationsResponse(registrations=[], next_page_token="def",), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(),], next_page_token="ghi", + ), + domains.ListRegistrationsResponse( + registrations=[domains.Registration(), domains.Registration(),], + ), + RuntimeError, + ) + pages = [] + async for page_ in (await client.list_registrations(request={})).pages: + pages.append(page_) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +def test_get_registration( + transport: str = "grpc", request_type=domains.GetRegistrationRequest +): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_registration), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = domains.Registration( + name="name_value", + domain_name="domain_name_value", + state=domains.Registration.State.REGISTRATION_PENDING, + issues=[domains.Registration.Issue.CONTACT_SUPPORT], + supported_privacy=[domains.ContactPrivacy.PUBLIC_CONTACT_DATA], + ) + response = client.get_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.GetRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.Registration) + assert response.name == "name_value" + assert response.domain_name == "domain_name_value" + assert response.state == domains.Registration.State.REGISTRATION_PENDING + assert response.issues == [domains.Registration.Issue.CONTACT_SUPPORT] + assert response.supported_privacy == [domains.ContactPrivacy.PUBLIC_CONTACT_DATA] + + +def test_get_registration_from_dict(): + test_get_registration(request_type=dict) + + +def test_get_registration_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 = DomainsClient( + 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.get_registration), "__call__") as call: + client.get_registration() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.GetRegistrationRequest() + + +@pytest.mark.asyncio +async def test_get_registration_async( + transport: str = "grpc_asyncio", request_type=domains.GetRegistrationRequest +): + client = DomainsAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_registration), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.Registration( + name="name_value", + domain_name="domain_name_value", + state=domains.Registration.State.REGISTRATION_PENDING, + issues=[domains.Registration.Issue.CONTACT_SUPPORT], + supported_privacy=[domains.ContactPrivacy.PUBLIC_CONTACT_DATA], + ) + ) + response = await client.get_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.GetRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.Registration) + assert response.name == "name_value" + assert response.domain_name == "domain_name_value" + assert response.state == domains.Registration.State.REGISTRATION_PENDING + assert response.issues == [domains.Registration.Issue.CONTACT_SUPPORT] + assert response.supported_privacy == [domains.ContactPrivacy.PUBLIC_CONTACT_DATA] + + +@pytest.mark.asyncio +async def test_get_registration_async_from_dict(): + await test_get_registration_async(request_type=dict) + + +def test_get_registration_field_headers(): + client = DomainsClient(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 = domains.GetRegistrationRequest() + + request.name = "name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_registration), "__call__") as call: + call.return_value = domains.Registration() + client.get_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "name=name/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_registration_field_headers_async(): + client = DomainsAsyncClient(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 = domains.GetRegistrationRequest() + + request.name = "name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_registration), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.Registration() + ) + await client.get_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "name=name/value",) in kw["metadata"] + + +def test_get_registration_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_registration), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = domains.Registration() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.get_registration(name="name_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].name == "name_value" + + +def test_get_registration_flattened_error(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_registration( + domains.GetRegistrationRequest(), name="name_value", + ) + + +@pytest.mark.asyncio +async def test_get_registration_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_registration), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = domains.Registration() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.Registration() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.get_registration(name="name_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].name == "name_value" + + +@pytest.mark.asyncio +async def test_get_registration_flattened_error_async(): + client = DomainsAsyncClient(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_registration( + domains.GetRegistrationRequest(), name="name_value", + ) + + +def test_update_registration( + transport: str = "grpc", request_type=domains.UpdateRegistrationRequest +): + client = DomainsClient( + 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_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.update_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.UpdateRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_update_registration_from_dict(): + test_update_registration(request_type=dict) + + +def test_update_registration_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 = DomainsClient( + 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_registration), "__call__" + ) as call: + client.update_registration() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.UpdateRegistrationRequest() + + +@pytest.mark.asyncio +async def test_update_registration_async( + transport: str = "grpc_asyncio", request_type=domains.UpdateRegistrationRequest +): + client = DomainsAsyncClient( + 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_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.update_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.UpdateRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_update_registration_async_from_dict(): + await test_update_registration_async(request_type=dict) + + +def test_update_registration_field_headers(): + client = DomainsClient(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 = domains.UpdateRegistrationRequest() + + request.registration.name = "registration.name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_registration), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.update_registration(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", + "registration.name=registration.name/value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_update_registration_field_headers_async(): + client = DomainsAsyncClient(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 = domains.UpdateRegistrationRequest() + + request.registration.name = "registration.name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_registration), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.update_registration(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", + "registration.name=registration.name/value", + ) in kw["metadata"] + + +def test_update_registration_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.update_registration( + registration=domains.Registration(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] + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +def test_update_registration_flattened_error(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_registration( + domains.UpdateRegistrationRequest(), + registration=domains.Registration(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.asyncio +async def test_update_registration_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.update_registration( + registration=domains.Registration(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] + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +@pytest.mark.asyncio +async def test_update_registration_flattened_error_async(): + client = DomainsAsyncClient(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_registration( + domains.UpdateRegistrationRequest(), + registration=domains.Registration(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_configure_management_settings( + transport: str = "grpc", request_type=domains.ConfigureManagementSettingsRequest +): + client = DomainsClient( + 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.configure_management_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.configure_management_settings(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureManagementSettingsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_configure_management_settings_from_dict(): + test_configure_management_settings(request_type=dict) + + +def test_configure_management_settings_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 = DomainsClient( + 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.configure_management_settings), "__call__" + ) as call: + client.configure_management_settings() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureManagementSettingsRequest() + + +@pytest.mark.asyncio +async def test_configure_management_settings_async( + transport: str = "grpc_asyncio", + request_type=domains.ConfigureManagementSettingsRequest, +): + client = DomainsAsyncClient( + 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.configure_management_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.configure_management_settings(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureManagementSettingsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_configure_management_settings_async_from_dict(): + await test_configure_management_settings_async(request_type=dict) + + +def test_configure_management_settings_field_headers(): + client = DomainsClient(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 = domains.ConfigureManagementSettingsRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_management_settings), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.configure_management_settings(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +@pytest.mark.asyncio +async def test_configure_management_settings_field_headers_async(): + client = DomainsAsyncClient(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 = domains.ConfigureManagementSettingsRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_management_settings), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.configure_management_settings(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +def test_configure_management_settings_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_management_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.configure_management_settings( + registration="registration_value", + management_settings=domains.ManagementSettings( + renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL + ), + 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] + assert args[0].registration == "registration_value" + assert args[0].management_settings == domains.ManagementSettings( + renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL + ) + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +def test_configure_management_settings_flattened_error(): + client = DomainsClient(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.configure_management_settings( + domains.ConfigureManagementSettingsRequest(), + registration="registration_value", + management_settings=domains.ManagementSettings( + renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.asyncio +async def test_configure_management_settings_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_management_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.configure_management_settings( + registration="registration_value", + management_settings=domains.ManagementSettings( + renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL + ), + 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] + assert args[0].registration == "registration_value" + assert args[0].management_settings == domains.ManagementSettings( + renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL + ) + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +@pytest.mark.asyncio +async def test_configure_management_settings_flattened_error_async(): + client = DomainsAsyncClient(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.configure_management_settings( + domains.ConfigureManagementSettingsRequest(), + registration="registration_value", + management_settings=domains.ManagementSettings( + renewal_method=domains.ManagementSettings.RenewalMethod.AUTOMATIC_RENEWAL + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_configure_dns_settings( + transport: str = "grpc", request_type=domains.ConfigureDnsSettingsRequest +): + client = DomainsClient( + 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.configure_dns_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.configure_dns_settings(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureDnsSettingsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_configure_dns_settings_from_dict(): + test_configure_dns_settings(request_type=dict) + + +def test_configure_dns_settings_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 = DomainsClient( + 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.configure_dns_settings), "__call__" + ) as call: + client.configure_dns_settings() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureDnsSettingsRequest() + + +@pytest.mark.asyncio +async def test_configure_dns_settings_async( + transport: str = "grpc_asyncio", request_type=domains.ConfigureDnsSettingsRequest +): + client = DomainsAsyncClient( + 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.configure_dns_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.configure_dns_settings(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureDnsSettingsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_configure_dns_settings_async_from_dict(): + await test_configure_dns_settings_async(request_type=dict) + + +def test_configure_dns_settings_field_headers(): + client = DomainsClient(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 = domains.ConfigureDnsSettingsRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_dns_settings), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.configure_dns_settings(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +@pytest.mark.asyncio +async def test_configure_dns_settings_field_headers_async(): + client = DomainsAsyncClient(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 = domains.ConfigureDnsSettingsRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_dns_settings), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.configure_dns_settings(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +def test_configure_dns_settings_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_dns_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.configure_dns_settings( + registration="registration_value", + dns_settings=domains.DnsSettings( + custom_dns=domains.DnsSettings.CustomDns( + name_servers=["name_servers_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] + assert args[0].registration == "registration_value" + assert args[0].dns_settings == domains.DnsSettings( + custom_dns=domains.DnsSettings.CustomDns( + name_servers=["name_servers_value"] + ) + ) + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +def test_configure_dns_settings_flattened_error(): + client = DomainsClient(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.configure_dns_settings( + domains.ConfigureDnsSettingsRequest(), + registration="registration_value", + dns_settings=domains.DnsSettings( + custom_dns=domains.DnsSettings.CustomDns( + name_servers=["name_servers_value"] + ) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.asyncio +async def test_configure_dns_settings_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_dns_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.configure_dns_settings( + registration="registration_value", + dns_settings=domains.DnsSettings( + custom_dns=domains.DnsSettings.CustomDns( + name_servers=["name_servers_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] + assert args[0].registration == "registration_value" + assert args[0].dns_settings == domains.DnsSettings( + custom_dns=domains.DnsSettings.CustomDns( + name_servers=["name_servers_value"] + ) + ) + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +@pytest.mark.asyncio +async def test_configure_dns_settings_flattened_error_async(): + client = DomainsAsyncClient(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.configure_dns_settings( + domains.ConfigureDnsSettingsRequest(), + registration="registration_value", + dns_settings=domains.DnsSettings( + custom_dns=domains.DnsSettings.CustomDns( + name_servers=["name_servers_value"] + ) + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_configure_contact_settings( + transport: str = "grpc", request_type=domains.ConfigureContactSettingsRequest +): + client = DomainsClient( + 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.configure_contact_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.configure_contact_settings(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureContactSettingsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_configure_contact_settings_from_dict(): + test_configure_contact_settings(request_type=dict) + + +def test_configure_contact_settings_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 = DomainsClient( + 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.configure_contact_settings), "__call__" + ) as call: + client.configure_contact_settings() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureContactSettingsRequest() + + +@pytest.mark.asyncio +async def test_configure_contact_settings_async( + transport: str = "grpc_asyncio", + request_type=domains.ConfigureContactSettingsRequest, +): + client = DomainsAsyncClient( + 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.configure_contact_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.configure_contact_settings(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ConfigureContactSettingsRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_configure_contact_settings_async_from_dict(): + await test_configure_contact_settings_async(request_type=dict) + + +def test_configure_contact_settings_field_headers(): + client = DomainsClient(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 = domains.ConfigureContactSettingsRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_contact_settings), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.configure_contact_settings(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +@pytest.mark.asyncio +async def test_configure_contact_settings_field_headers_async(): + client = DomainsAsyncClient(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 = domains.ConfigureContactSettingsRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_contact_settings), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.configure_contact_settings(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +def test_configure_contact_settings_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_contact_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.configure_contact_settings( + registration="registration_value", + contact_settings=domains.ContactSettings( + privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA + ), + 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] + assert args[0].registration == "registration_value" + assert args[0].contact_settings == domains.ContactSettings( + privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA + ) + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +def test_configure_contact_settings_flattened_error(): + client = DomainsClient(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.configure_contact_settings( + domains.ConfigureContactSettingsRequest(), + registration="registration_value", + contact_settings=domains.ContactSettings( + privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +@pytest.mark.asyncio +async def test_configure_contact_settings_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.configure_contact_settings), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.configure_contact_settings( + registration="registration_value", + contact_settings=domains.ContactSettings( + privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA + ), + 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] + assert args[0].registration == "registration_value" + assert args[0].contact_settings == domains.ContactSettings( + privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA + ) + assert args[0].update_mask == field_mask_pb2.FieldMask(paths=["paths_value"]) + + +@pytest.mark.asyncio +async def test_configure_contact_settings_flattened_error_async(): + client = DomainsAsyncClient(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.configure_contact_settings( + domains.ConfigureContactSettingsRequest(), + registration="registration_value", + contact_settings=domains.ContactSettings( + privacy=domains.ContactPrivacy.PUBLIC_CONTACT_DATA + ), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_export_registration( + transport: str = "grpc", request_type=domains.ExportRegistrationRequest +): + client = DomainsClient( + 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.export_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.export_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ExportRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_export_registration_from_dict(): + test_export_registration(request_type=dict) + + +def test_export_registration_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 = DomainsClient( + 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.export_registration), "__call__" + ) as call: + client.export_registration() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ExportRegistrationRequest() + + +@pytest.mark.asyncio +async def test_export_registration_async( + transport: str = "grpc_asyncio", request_type=domains.ExportRegistrationRequest +): + client = DomainsAsyncClient( + 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.export_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.export_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ExportRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_export_registration_async_from_dict(): + await test_export_registration_async(request_type=dict) + + +def test_export_registration_field_headers(): + client = DomainsClient(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 = domains.ExportRegistrationRequest() + + request.name = "name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.export_registration), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.export_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "name=name/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_export_registration_field_headers_async(): + client = DomainsAsyncClient(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 = domains.ExportRegistrationRequest() + + request.name = "name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.export_registration), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.export_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "name=name/value",) in kw["metadata"] + + +def test_export_registration_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.export_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.export_registration(name="name_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].name == "name_value" + + +def test_export_registration_flattened_error(): + client = DomainsClient(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.export_registration( + domains.ExportRegistrationRequest(), name="name_value", + ) + + +@pytest.mark.asyncio +async def test_export_registration_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.export_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.export_registration(name="name_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].name == "name_value" + + +@pytest.mark.asyncio +async def test_export_registration_flattened_error_async(): + client = DomainsAsyncClient(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.export_registration( + domains.ExportRegistrationRequest(), name="name_value", + ) + + +def test_delete_registration( + transport: str = "grpc", request_type=domains.DeleteRegistrationRequest +): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.delete_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.DeleteRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_delete_registration_from_dict(): + test_delete_registration(request_type=dict) + + +def test_delete_registration_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 = DomainsClient( + 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.delete_registration), "__call__" + ) as call: + client.delete_registration() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.DeleteRegistrationRequest() + + +@pytest.mark.asyncio +async def test_delete_registration_async( + transport: str = "grpc_asyncio", request_type=domains.DeleteRegistrationRequest +): + client = DomainsAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.delete_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.DeleteRegistrationRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_delete_registration_async_from_dict(): + await test_delete_registration_async(request_type=dict) + + +def test_delete_registration_field_headers(): + client = DomainsClient(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 = domains.DeleteRegistrationRequest() + + request.name = "name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_registration), "__call__" + ) as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.delete_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "name=name/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_registration_field_headers_async(): + client = DomainsAsyncClient(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 = domains.DeleteRegistrationRequest() + + request.name = "name/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_registration), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.delete_registration(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "name=name/value",) in kw["metadata"] + + +def test_delete_registration_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.delete_registration(name="name_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].name == "name_value" + + +def test_delete_registration_flattened_error(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_registration( + domains.DeleteRegistrationRequest(), name="name_value", + ) + + +@pytest.mark.asyncio +async def test_delete_registration_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_registration), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.delete_registration(name="name_value",) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].name == "name_value" + + +@pytest.mark.asyncio +async def test_delete_registration_flattened_error_async(): + client = DomainsAsyncClient(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.delete_registration( + domains.DeleteRegistrationRequest(), name="name_value", + ) + + +def test_retrieve_authorization_code( + transport: str = "grpc", request_type=domains.RetrieveAuthorizationCodeRequest +): + client = DomainsClient( + 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.retrieve_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.AuthorizationCode(code="code_value",) + response = client.retrieve_authorization_code(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveAuthorizationCodeRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.AuthorizationCode) + assert response.code == "code_value" + + +def test_retrieve_authorization_code_from_dict(): + test_retrieve_authorization_code(request_type=dict) + + +def test_retrieve_authorization_code_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 = DomainsClient( + 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.retrieve_authorization_code), "__call__" + ) as call: + client.retrieve_authorization_code() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveAuthorizationCodeRequest() + + +@pytest.mark.asyncio +async def test_retrieve_authorization_code_async( + transport: str = "grpc_asyncio", + request_type=domains.RetrieveAuthorizationCodeRequest, +): + client = DomainsAsyncClient( + 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.retrieve_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.AuthorizationCode(code="code_value",) + ) + response = await client.retrieve_authorization_code(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveAuthorizationCodeRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.AuthorizationCode) + assert response.code == "code_value" + + +@pytest.mark.asyncio +async def test_retrieve_authorization_code_async_from_dict(): + await test_retrieve_authorization_code_async(request_type=dict) + + +def test_retrieve_authorization_code_field_headers(): + client = DomainsClient(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 = domains.RetrieveAuthorizationCodeRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_authorization_code), "__call__" + ) as call: + call.return_value = domains.AuthorizationCode() + client.retrieve_authorization_code(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +@pytest.mark.asyncio +async def test_retrieve_authorization_code_field_headers_async(): + client = DomainsAsyncClient(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 = domains.RetrieveAuthorizationCodeRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_authorization_code), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.AuthorizationCode() + ) + await client.retrieve_authorization_code(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +def test_retrieve_authorization_code_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.AuthorizationCode() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.retrieve_authorization_code(registration="registration_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] + assert args[0].registration == "registration_value" + + +def test_retrieve_authorization_code_flattened_error(): + client = DomainsClient(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.retrieve_authorization_code( + domains.RetrieveAuthorizationCodeRequest(), + registration="registration_value", + ) + + +@pytest.mark.asyncio +async def test_retrieve_authorization_code_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.AuthorizationCode() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.AuthorizationCode() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.retrieve_authorization_code( + registration="registration_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].registration == "registration_value" + + +@pytest.mark.asyncio +async def test_retrieve_authorization_code_flattened_error_async(): + client = DomainsAsyncClient(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.retrieve_authorization_code( + domains.RetrieveAuthorizationCodeRequest(), + registration="registration_value", + ) + + +def test_reset_authorization_code( + transport: str = "grpc", request_type=domains.ResetAuthorizationCodeRequest +): + client = DomainsClient( + 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.reset_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.AuthorizationCode(code="code_value",) + response = client.reset_authorization_code(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ResetAuthorizationCodeRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.AuthorizationCode) + assert response.code == "code_value" + + +def test_reset_authorization_code_from_dict(): + test_reset_authorization_code(request_type=dict) + + +def test_reset_authorization_code_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 = DomainsClient( + 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.reset_authorization_code), "__call__" + ) as call: + client.reset_authorization_code() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ResetAuthorizationCodeRequest() + + +@pytest.mark.asyncio +async def test_reset_authorization_code_async( + transport: str = "grpc_asyncio", request_type=domains.ResetAuthorizationCodeRequest +): + client = DomainsAsyncClient( + 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.reset_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.AuthorizationCode(code="code_value",) + ) + response = await client.reset_authorization_code(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.ResetAuthorizationCodeRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.AuthorizationCode) + assert response.code == "code_value" + + +@pytest.mark.asyncio +async def test_reset_authorization_code_async_from_dict(): + await test_reset_authorization_code_async(request_type=dict) + + +def test_reset_authorization_code_field_headers(): + client = DomainsClient(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 = domains.ResetAuthorizationCodeRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.reset_authorization_code), "__call__" + ) as call: + call.return_value = domains.AuthorizationCode() + client.reset_authorization_code(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +@pytest.mark.asyncio +async def test_reset_authorization_code_field_headers_async(): + client = DomainsAsyncClient(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 = domains.ResetAuthorizationCodeRequest() + + request.registration = "registration/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.reset_authorization_code), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.AuthorizationCode() + ) + await client.reset_authorization_code(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", "registration=registration/value",) in kw[ + "metadata" + ] + + +def test_reset_authorization_code_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.reset_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.AuthorizationCode() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.reset_authorization_code(registration="registration_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] + assert args[0].registration == "registration_value" + + +def test_reset_authorization_code_flattened_error(): + client = DomainsClient(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.reset_authorization_code( + domains.ResetAuthorizationCodeRequest(), registration="registration_value", + ) + + +@pytest.mark.asyncio +async def test_reset_authorization_code_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.reset_authorization_code), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.AuthorizationCode() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.AuthorizationCode() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.reset_authorization_code( + registration="registration_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].registration == "registration_value" + + +@pytest.mark.asyncio +async def test_reset_authorization_code_flattened_error_async(): + client = DomainsAsyncClient(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.reset_authorization_code( + domains.ResetAuthorizationCodeRequest(), registration="registration_value", + ) + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.DomainsGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.DomainsGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = DomainsClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.DomainsGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = DomainsClient( + client_options={"scopes": ["1", "2"]}, transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.DomainsGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = DomainsClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.DomainsGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.DomainsGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport,], +) +def test_transport_adc(transport_class): + # Test default credentials are used if not provided. + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class() + adc.assert_called_once() + + +def test_transport_grpc_default(): + # A client should use the gRPC transport by default. + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + assert isinstance(client.transport, transports.DomainsGrpcTransport,) + + +def test_domains_base_transport_error(): + # Passing both a credentials object and credentials_file should raise an error + with pytest.raises(core_exceptions.DuplicateCredentialArgs): + transport = transports.DomainsTransport( + credentials=ga_credentials.AnonymousCredentials(), + credentials_file="credentials.json", + ) + + +def test_domains_base_transport(): + # Instantiate the base transport. + with mock.patch( + "google.cloud.domains_v1.services.domains.transports.DomainsTransport.__init__" + ) as Transport: + Transport.return_value = None + transport = transports.DomainsTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Every method on the transport should just blindly + # raise NotImplementedError. + methods = ( + "search_domains", + "retrieve_register_parameters", + "register_domain", + "retrieve_transfer_parameters", + "transfer_domain", + "list_registrations", + "get_registration", + "update_registration", + "configure_management_settings", + "configure_dns_settings", + "configure_contact_settings", + "export_registration", + "delete_registration", + "retrieve_authorization_code", + "reset_authorization_code", + ) + for method in methods: + with pytest.raises(NotImplementedError): + getattr(transport, method)(request=object()) + + with pytest.raises(NotImplementedError): + transport.close() + + # Additionally, the LRO client (a property) should + # also raise NotImplementedError + with pytest.raises(NotImplementedError): + transport.operations_client + + +@requires_google_auth_gte_1_25_0 +def test_domains_base_transport_with_credentials_file(): + # Instantiate the base transport with a credentials file + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch( + "google.cloud.domains_v1.services.domains.transports.DomainsTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.DomainsTransport( + credentials_file="credentials.json", quota_project_id="octopus", + ) + load_creds.assert_called_once_with( + "credentials.json", + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +@requires_google_auth_lt_1_25_0 +def test_domains_base_transport_with_credentials_file_old_google_auth(): + # Instantiate the base transport with a credentials file + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch( + "google.cloud.domains_v1.services.domains.transports.DomainsTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.DomainsTransport( + credentials_file="credentials.json", quota_project_id="octopus", + ) + load_creds.assert_called_once_with( + "credentials.json", + scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +def test_domains_base_transport_with_adc(): + # Test the default credentials are used if credentials and credentials_file are None. + with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch( + "google.cloud.domains_v1.services.domains.transports.DomainsTransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.DomainsTransport() + adc.assert_called_once() + + +@requires_google_auth_gte_1_25_0 +def test_domains_auth_adc(): + # If no credentials are provided, we should use ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + DomainsClient() + adc.assert_called_once_with( + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id=None, + ) + + +@requires_google_auth_lt_1_25_0 +def test_domains_auth_adc_old_google_auth(): + # If no credentials are provided, we should use ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + DomainsClient() + adc.assert_called_once_with( + scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id=None, + ) + + +@pytest.mark.parametrize( + "transport_class", + [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport,], +) +@requires_google_auth_gte_1_25_0 +def test_domains_transport_auth_adc(transport_class): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class(quota_project_id="octopus", scopes=["1", "2"]) + adc.assert_called_once_with( + scopes=["1", "2"], + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +@pytest.mark.parametrize( + "transport_class", + [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport,], +) +@requires_google_auth_lt_1_25_0 +def test_domains_transport_auth_adc_old_google_auth(transport_class): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object(google.auth, "default", autospec=True) as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class(quota_project_id="octopus") + adc.assert_called_once_with( + scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +@pytest.mark.parametrize( + "transport_class,grpc_helpers", + [ + (transports.DomainsGrpcTransport, grpc_helpers), + (transports.DomainsGrpcAsyncIOTransport, grpc_helpers_async), + ], +) +def test_domains_transport_create_channel(transport_class, grpc_helpers): + # If credentials and host are not provided, the transport class should use + # ADC credentials. + with mock.patch.object( + google.auth, "default", autospec=True + ) as adc, mock.patch.object( + grpc_helpers, "create_channel", autospec=True + ) as create_channel: + creds = ga_credentials.AnonymousCredentials() + adc.return_value = (creds, None) + transport_class(quota_project_id="octopus", scopes=["1", "2"]) + + create_channel.assert_called_with( + "domains.googleapis.com:443", + credentials=creds, + credentials_file=None, + quota_project_id="octopus", + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + scopes=["1", "2"], + default_host="domains.googleapis.com", + ssl_credentials=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + +@pytest.mark.parametrize( + "transport_class", + [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport], +) +def test_domains_grpc_transport_client_cert_source_for_mtls(transport_class): + cred = ga_credentials.AnonymousCredentials() + + # Check ssl_channel_credentials is used if provided. + with mock.patch.object(transport_class, "create_channel") as mock_create_channel: + mock_ssl_channel_creds = mock.Mock() + transport_class( + host="squid.clam.whelk", + credentials=cred, + ssl_channel_credentials=mock_ssl_channel_creds, + ) + mock_create_channel.assert_called_once_with( + "squid.clam.whelk:443", + credentials=cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_channel_creds, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + + # Check if ssl_channel_credentials is not provided, then client_cert_source_for_mtls + # is used. + with mock.patch.object(transport_class, "create_channel", return_value=mock.Mock()): + with mock.patch("grpc.ssl_channel_credentials") as mock_ssl_cred: + transport_class( + credentials=cred, + client_cert_source_for_mtls=client_cert_source_callback, + ) + expected_cert, expected_key = client_cert_source_callback() + mock_ssl_cred.assert_called_once_with( + certificate_chain=expected_cert, private_key=expected_key + ) + + +def test_domains_host_no_port(): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), + client_options=client_options.ClientOptions( + api_endpoint="domains.googleapis.com" + ), + ) + assert client.transport._host == "domains.googleapis.com:443" + + +def test_domains_host_with_port(): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), + client_options=client_options.ClientOptions( + api_endpoint="domains.googleapis.com:8000" + ), + ) + assert client.transport._host == "domains.googleapis.com:8000" + + +def test_domains_grpc_transport_channel(): + channel = grpc.secure_channel("http://localhost/", grpc.local_channel_credentials()) + + # Check that channel is used if provided. + transport = transports.DomainsGrpcTransport( + host="squid.clam.whelk", channel=channel, + ) + assert transport.grpc_channel == channel + assert transport._host == "squid.clam.whelk:443" + assert transport._ssl_channel_credentials == None + + +def test_domains_grpc_asyncio_transport_channel(): + channel = aio.secure_channel("http://localhost/", grpc.local_channel_credentials()) + + # Check that channel is used if provided. + transport = transports.DomainsGrpcAsyncIOTransport( + host="squid.clam.whelk", channel=channel, + ) + assert transport.grpc_channel == channel + assert transport._host == "squid.clam.whelk:443" + assert transport._ssl_channel_credentials == None + + +# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are +# removed from grpc/grpc_asyncio transport constructor. +@pytest.mark.parametrize( + "transport_class", + [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport], +) +def test_domains_transport_channel_mtls_with_client_cert_source(transport_class): + with mock.patch( + "grpc.ssl_channel_credentials", autospec=True + ) as grpc_ssl_channel_cred: + with mock.patch.object( + transport_class, "create_channel" + ) as grpc_create_channel: + mock_ssl_cred = mock.Mock() + grpc_ssl_channel_cred.return_value = mock_ssl_cred + + mock_grpc_channel = mock.Mock() + grpc_create_channel.return_value = mock_grpc_channel + + cred = ga_credentials.AnonymousCredentials() + with pytest.warns(DeprecationWarning): + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (cred, None) + transport = transport_class( + host="squid.clam.whelk", + api_mtls_endpoint="mtls.squid.clam.whelk", + client_cert_source=client_cert_source_callback, + ) + adc.assert_called_once() + + grpc_ssl_channel_cred.assert_called_once_with( + certificate_chain=b"cert bytes", private_key=b"key bytes" + ) + grpc_create_channel.assert_called_once_with( + "mtls.squid.clam.whelk:443", + credentials=cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_cred, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + assert transport.grpc_channel == mock_grpc_channel + assert transport._ssl_channel_credentials == mock_ssl_cred + + +# Remove this test when deprecated arguments (api_mtls_endpoint, client_cert_source) are +# removed from grpc/grpc_asyncio transport constructor. +@pytest.mark.parametrize( + "transport_class", + [transports.DomainsGrpcTransport, transports.DomainsGrpcAsyncIOTransport], +) +def test_domains_transport_channel_mtls_with_adc(transport_class): + mock_ssl_cred = mock.Mock() + with mock.patch.multiple( + "google.auth.transport.grpc.SslCredentials", + __init__=mock.Mock(return_value=None), + ssl_credentials=mock.PropertyMock(return_value=mock_ssl_cred), + ): + with mock.patch.object( + transport_class, "create_channel" + ) as grpc_create_channel: + mock_grpc_channel = mock.Mock() + grpc_create_channel.return_value = mock_grpc_channel + mock_cred = mock.Mock() + + with pytest.warns(DeprecationWarning): + transport = transport_class( + host="squid.clam.whelk", + credentials=mock_cred, + api_mtls_endpoint="mtls.squid.clam.whelk", + client_cert_source=None, + ) + + grpc_create_channel.assert_called_once_with( + "mtls.squid.clam.whelk:443", + credentials=mock_cred, + credentials_file=None, + scopes=None, + ssl_credentials=mock_ssl_cred, + quota_project_id=None, + options=[ + ("grpc.max_send_message_length", -1), + ("grpc.max_receive_message_length", -1), + ], + ) + assert transport.grpc_channel == mock_grpc_channel + + +def test_domains_grpc_lro_client(): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + ) + transport = client.transport + + # Ensure that we have a api-core operations client. + assert isinstance(transport.operations_client, operations_v1.OperationsClient,) + + # Ensure that subsequent calls to the property send the exact same object. + assert transport.operations_client is transport.operations_client + + +def test_domains_grpc_lro_async_client(): + client = DomainsAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc_asyncio", + ) + transport = client.transport + + # Ensure that we have a api-core operations client. + assert isinstance(transport.operations_client, operations_v1.OperationsAsyncClient,) + + # Ensure that subsequent calls to the property send the exact same object. + assert transport.operations_client is transport.operations_client + + +def test_registration_path(): + project = "squid" + location = "clam" + registration = "whelk" + expected = "projects/{project}/locations/{location}/registrations/{registration}".format( + project=project, location=location, registration=registration, + ) + actual = DomainsClient.registration_path(project, location, registration) + assert expected == actual + + +def test_parse_registration_path(): + expected = { + "project": "octopus", + "location": "oyster", + "registration": "nudibranch", + } + path = DomainsClient.registration_path(**expected) + + # Check that the path construction is reversible. + actual = DomainsClient.parse_registration_path(path) + assert expected == actual + + +def test_common_billing_account_path(): + billing_account = "cuttlefish" + expected = "billingAccounts/{billing_account}".format( + billing_account=billing_account, + ) + actual = DomainsClient.common_billing_account_path(billing_account) + assert expected == actual + + +def test_parse_common_billing_account_path(): + expected = { + "billing_account": "mussel", + } + path = DomainsClient.common_billing_account_path(**expected) + + # Check that the path construction is reversible. + actual = DomainsClient.parse_common_billing_account_path(path) + assert expected == actual + + +def test_common_folder_path(): + folder = "winkle" + expected = "folders/{folder}".format(folder=folder,) + actual = DomainsClient.common_folder_path(folder) + assert expected == actual + + +def test_parse_common_folder_path(): + expected = { + "folder": "nautilus", + } + path = DomainsClient.common_folder_path(**expected) + + # Check that the path construction is reversible. + actual = DomainsClient.parse_common_folder_path(path) + assert expected == actual + + +def test_common_organization_path(): + organization = "scallop" + expected = "organizations/{organization}".format(organization=organization,) + actual = DomainsClient.common_organization_path(organization) + assert expected == actual + + +def test_parse_common_organization_path(): + expected = { + "organization": "abalone", + } + path = DomainsClient.common_organization_path(**expected) + + # Check that the path construction is reversible. + actual = DomainsClient.parse_common_organization_path(path) + assert expected == actual + + +def test_common_project_path(): + project = "squid" + expected = "projects/{project}".format(project=project,) + actual = DomainsClient.common_project_path(project) + assert expected == actual + + +def test_parse_common_project_path(): + expected = { + "project": "clam", + } + path = DomainsClient.common_project_path(**expected) + + # Check that the path construction is reversible. + actual = DomainsClient.parse_common_project_path(path) + assert expected == actual + + +def test_common_location_path(): + project = "whelk" + location = "octopus" + expected = "projects/{project}/locations/{location}".format( + project=project, location=location, + ) + actual = DomainsClient.common_location_path(project, location) + assert expected == actual + + +def test_parse_common_location_path(): + expected = { + "project": "oyster", + "location": "nudibranch", + } + path = DomainsClient.common_location_path(**expected) + + # Check that the path construction is reversible. + actual = DomainsClient.parse_common_location_path(path) + assert expected == actual + + +def test_client_withDEFAULT_CLIENT_INFO(): + client_info = gapic_v1.client_info.ClientInfo() + + with mock.patch.object( + transports.DomainsTransport, "_prep_wrapped_messages" + ) as prep: + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), client_info=client_info, + ) + prep.assert_called_once_with(client_info) + + with mock.patch.object( + transports.DomainsTransport, "_prep_wrapped_messages" + ) as prep: + transport_class = DomainsClient.get_transport_class() + transport = transport_class( + credentials=ga_credentials.AnonymousCredentials(), client_info=client_info, + ) + prep.assert_called_once_with(client_info) + + +@pytest.mark.asyncio +async def test_transport_close_async(): + client = DomainsAsyncClient( + credentials=ga_credentials.AnonymousCredentials(), transport="grpc_asyncio", + ) + with mock.patch.object( + type(getattr(client.transport, "grpc_channel")), "close" + ) as close: + async with client: + close.assert_not_called() + close.assert_called_once() + + +def test_transport_close(): + transports = { + "grpc": "_grpc_channel", + } + + for transport, close_name in transports.items(): + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport + ) + with mock.patch.object( + type(getattr(client.transport, close_name)), "close" + ) as close: + with client: + close.assert_not_called() + close.assert_called_once() + + +def test_client_ctx(): + transports = [ + "grpc", + ] + for transport in transports: + client = DomainsClient( + credentials=ga_credentials.AnonymousCredentials(), transport=transport + ) + # Test client calls underlying transport. + with mock.patch.object(type(client.transport), "close") as close: + close.assert_not_called() + with client: + pass + close.assert_called() diff --git a/tests/unit/gapic/domains_v1beta1/test_domains.py b/tests/unit/gapic/domains_v1beta1/test_domains.py index c3c2c7d..88d273c 100644 --- a/tests/unit/gapic/domains_v1beta1/test_domains.py +++ b/tests/unit/gapic/domains_v1beta1/test_domains.py @@ -1106,6 +1106,451 @@ async def test_register_domain_flattened_error_async(): ) +def test_retrieve_transfer_parameters( + transport: str = "grpc", request_type=domains.RetrieveTransferParametersRequest +): + client = DomainsClient( + 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.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveTransferParametersResponse() + response = client.retrieve_transfer_parameters(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveTransferParametersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.RetrieveTransferParametersResponse) + + +def test_retrieve_transfer_parameters_from_dict(): + test_retrieve_transfer_parameters(request_type=dict) + + +def test_retrieve_transfer_parameters_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 = DomainsClient( + 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.retrieve_transfer_parameters), "__call__" + ) as call: + client.retrieve_transfer_parameters() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveTransferParametersRequest() + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_async( + transport: str = "grpc_asyncio", + request_type=domains.RetrieveTransferParametersRequest, +): + client = DomainsAsyncClient( + 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.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveTransferParametersResponse() + ) + response = await client.retrieve_transfer_parameters(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.RetrieveTransferParametersRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, domains.RetrieveTransferParametersResponse) + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_async_from_dict(): + await test_retrieve_transfer_parameters_async(request_type=dict) + + +def test_retrieve_transfer_parameters_field_headers(): + client = DomainsClient(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 = domains.RetrieveTransferParametersRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + call.return_value = domains.RetrieveTransferParametersResponse() + client.retrieve_transfer_parameters(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", "location=location/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_field_headers_async(): + client = DomainsAsyncClient(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 = domains.RetrieveTransferParametersRequest() + + request.location = "location/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveTransferParametersResponse() + ) + await client.retrieve_transfer_parameters(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", "location=location/value",) in kw["metadata"] + + +def test_retrieve_transfer_parameters_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveTransferParametersResponse() + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.retrieve_transfer_parameters( + location="location_value", domain_name="domain_name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].domain_name == "domain_name_value" + + +def test_retrieve_transfer_parameters_flattened_error(): + client = DomainsClient(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.retrieve_transfer_parameters( + domains.RetrieveTransferParametersRequest(), + location="location_value", + domain_name="domain_name_value", + ) + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.retrieve_transfer_parameters), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = domains.RetrieveTransferParametersResponse() + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + domains.RetrieveTransferParametersResponse() + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.retrieve_transfer_parameters( + location="location_value", domain_name="domain_name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].location == "location_value" + assert args[0].domain_name == "domain_name_value" + + +@pytest.mark.asyncio +async def test_retrieve_transfer_parameters_flattened_error_async(): + client = DomainsAsyncClient(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.retrieve_transfer_parameters( + domains.RetrieveTransferParametersRequest(), + location="location_value", + domain_name="domain_name_value", + ) + + +def test_transfer_domain( + transport: str = "grpc", request_type=domains.TransferDomainRequest +): + client = DomainsClient( + 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.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/spam") + response = client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == domains.TransferDomainRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +def test_transfer_domain_from_dict(): + test_transfer_domain(request_type=dict) + + +def test_transfer_domain_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 = DomainsClient( + 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.transfer_domain), "__call__") as call: + client.transfer_domain() + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == domains.TransferDomainRequest() + + +@pytest.mark.asyncio +async def test_transfer_domain_async( + transport: str = "grpc_asyncio", request_type=domains.TransferDomainRequest +): + client = DomainsAsyncClient( + 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.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + response = await client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == domains.TransferDomainRequest() + + # Establish that the response is the type that we expect. + assert isinstance(response, future.Future) + + +@pytest.mark.asyncio +async def test_transfer_domain_async_from_dict(): + await test_transfer_domain_async(request_type=dict) + + +def test_transfer_domain_field_headers(): + client = DomainsClient(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 = domains.TransferDomainRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + call.return_value = operations_pb2.Operation(name="operations/op") + client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_transfer_domain_field_headers_async(): + client = DomainsAsyncClient(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 = domains.TransferDomainRequest() + + request.parent = "parent/value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/op") + ) + await client.transfer_domain(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ("x-goog-request-params", "parent=parent/value",) in kw["metadata"] + + +def test_transfer_domain_flattened(): + client = DomainsClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.transfer_domain( + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_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] + assert args[0].parent == "parent_value" + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].yearly_price == money_pb2.Money( + currency_code="currency_code_value" + ) + assert args[0].authorization_code == domains.AuthorizationCode( + code="code_value" + ) + + +def test_transfer_domain_flattened_error(): + client = DomainsClient(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.transfer_domain( + domains.TransferDomainRequest(), + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_value"), + ) + + +@pytest.mark.asyncio +async def test_transfer_domain_flattened_async(): + client = DomainsAsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.transfer_domain), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = operations_pb2.Operation(name="operations/op") + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + operations_pb2.Operation(name="operations/spam") + ) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.transfer_domain( + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_value"), + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0].parent == "parent_value" + assert args[0].registration == domains.Registration(name="name_value") + assert args[0].yearly_price == money_pb2.Money( + currency_code="currency_code_value" + ) + assert args[0].authorization_code == domains.AuthorizationCode( + code="code_value" + ) + + +@pytest.mark.asyncio +async def test_transfer_domain_flattened_error_async(): + client = DomainsAsyncClient(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.transfer_domain( + domains.TransferDomainRequest(), + parent="parent_value", + registration=domains.Registration(name="name_value"), + yearly_price=money_pb2.Money(currency_code="currency_code_value"), + authorization_code=domains.AuthorizationCode(code="code_value"), + ) + + def test_list_registrations( transport: str = "grpc", request_type=domains.ListRegistrationsRequest ): @@ -3594,6 +4039,8 @@ def test_domains_base_transport(): "search_domains", "retrieve_register_parameters", "register_domain", + "retrieve_transfer_parameters", + "transfer_domain", "list_registrations", "get_registration", "update_registration",