def test_intercept_unary_stream(self):
        interceptor = MetadataInterceptor(
            self.mock_developer_token,
            self.mock_login_customer_id,
            self.mock_linked_customer_id,
        )

        mock_continuation = mock.Mock(return_value=None)
        mock_client_call_details = mock.Mock()
        mock_client_call_details.method = "test/method"
        mock_client_call_details.timeout = 5
        mock_client_call_details.metadata = [("apples", "oranges")]
        mock_request = mock.Mock()

        with mock.patch.object(
                interceptor,
                "_update_client_call_details_metadata",
                wraps=interceptor._update_client_call_details_metadata,
        ) as mock_updater:
            interceptor.intercept_unary_stream(mock_continuation,
                                               mock_client_call_details,
                                               mock_request)

            mock_updater.assert_called_once_with(
                mock_client_call_details,
                [
                    mock_client_call_details.metadata[0],
                    interceptor.developer_token_meta,
                    interceptor.login_customer_id_meta,
                    interceptor.linked_customer_id_meta,
                ],
            )

            mock_continuation.assert_called_once()
    def test_intercept_unary_unary(self):
        interceptor = MetadataInterceptor(
            self.mock_developer_token,
            self.mock_login_customer_id)

        mock_continuation = mock.Mock(return_value=None)
        mock_client_call_details = mock.Mock()
        mock_client_call_details.method = 'test/method'
        mock_client_call_details.timeout = 5
        mock_client_call_details.metadata = [('apples', 'oranges')]
        mock_request = mock.Mock()

        with mock.patch.object(
            interceptor,
            '_update_client_call_details_metadata',
            wraps=interceptor._update_client_call_details_metadata
        ) as mock_updater:
            interceptor.intercept_unary_unary(
                mock_continuation,
                mock_client_call_details,
                mock_request)

            mock_updater.assert_called_once_with(
                mock_client_call_details, [mock_client_call_details.metadata[0],
                                           interceptor.developer_token_meta,
                                           interceptor.login_customer_id_meta])

            mock_continuation.assert_called_once()
Ejemplo n.º 3
0
    def test_update_client_call_details_metadata(self):
        interceptor = MetadataInterceptor(self.mock_developer_token,
                                          self.mock_login_customer_id)

        mock_metadata = list([("test-key", "test-value")])
        mock_client_call_details = mock.Mock()

        client_call_details = interceptor._update_client_call_details_metadata(
            mock_client_call_details, mock_metadata)

        self.assertEqual(client_call_details.metadata, mock_metadata)
Ejemplo n.º 4
0
    def test_init_no_login_customer_id(self):
        interceptor = MetadataInterceptor(self.mock_developer_token, None)

        self.assertEqual(interceptor.developer_token_meta,
                         ('developer-token', self.mock_developer_token))

        self.assertEqual(interceptor.login_customer_id_meta, None)
Ejemplo n.º 5
0
    def test_init(self):
        interceptor = MetadataInterceptor(self.mock_developer_token,
                                          self.mock_login_customer_id)

        self.assertEqual(interceptor.developer_token_meta,
                         ('developer-token', self.mock_developer_token))

        self.assertEqual(interceptor.login_customer_id_meta,
                         ('login-customer-id', self.mock_login_customer_id))
Ejemplo n.º 6
0
    def get_service(self, name, version=_DEFAULT_VERSION, interceptors=None):
        """Returns a service client instance for the specified service_name.

        Args:
            name: a str indicating the name of the service for which a
                service client is being retrieved; e.g. you may specify
                "CampaignService" to retrieve a CampaignServiceClient instance.
            version: a str indicating the version of the Google Ads API to be
                used.
            interceptors: an optional list of interceptors to include in
                requests. NOTE: this parameter is not intended for non-Google
                use and is not officially supported.

        Returns:
            A service client instance associated with the given service_name.

        Raises:
            AttributeError: If the specified name doesn't exist.
        """
        api_module = self._get_api_services_by_version(version)
        interceptors = interceptors or []

        try:
            service_client = getattr(api_module,
                                     _SERVICE_CLIENT_TEMPLATE.format(name))
        except AttributeError:
            raise ValueError('Specified service {}" does not exist in Google '
                             'Ads API {}.'.format(name, version))

        try:
            service_transport_class = getattr(
                api_module, _SERVICE_GRPC_TRANSPORT_TEMPLATE.format(name))
        except AttributeError:
            raise ValueError('Grpc transport does not exist for the specified '
                             'service "{}".'.format(name))

        endpoint = (self.endpoint if self.endpoint
                    else service_client.SERVICE_ADDRESS)

        channel = service_transport_class.create_channel(
            address=endpoint,
            credentials=self.credentials,
            options=_GRPC_CHANNEL_OPTIONS)

        interceptors = interceptors + [
            MetadataInterceptor(self.developer_token, self.login_customer_id),
            LoggingInterceptor(_logger, version, endpoint),
            ExceptionInterceptor(version)]

        channel = grpc.intercept_channel(
            channel,
            *interceptors)

        service_transport = service_transport_class(channel=channel)

        return service_client(transport=service_transport)
    def test_init_no_linked_customer_id(self):
        interceptor = MetadataInterceptor(self.mock_developer_token, None,
                                          None)

        self.assertEqual(
            interceptor.developer_token_meta,
            ("developer-token", self.mock_developer_token),
        )

        self.assertEqual(interceptor.linked_customer_id_meta, None)