google--adk-python/tests/unittests/integrations/secret_manager/test_secret_client.py

# Copyright 2026 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.

"""Unit tests for the SecretManagerClient."""

import json
from unittest.mock import MagicMock
from unittest.mock import patch

from google.adk.integrations.secret_manager.secret_client import SecretManagerClient
from google.adk.integrations.secret_manager.secret_client import USER_AGENT
from google.api_core.gapic_v1 import client_info
from google.oauth2.credentials import Credentials
import pytest

import google


class TestSecretManagerClient:
  """Tests for the SecretManagerClient class."""

  @patch("google.cloud.secretmanager.SecretManagerServiceClient")
  @patch(
      "google.adk.integrations.secret_manager.secret_client.default_service_credential"
  )
  def test_init_with_default_credentials(
      self, mock_default_service_credential, mock_secret_manager_client
  ):
    """Test initialization with default credentials."""
    # Setup
    mock_credentials = MagicMock()
    mock_default_service_credential.return_value = (
        mock_credentials,
        "test-project",
    )

    # Execute
    client = SecretManagerClient()

    # Verify
    mock_default_service_credential.assert_called_once_with(
        scopes=["https://www.googleapis.com/auth/cloud-platform"]
    )
    mock_secret_manager_client.assert_called_once()
    call_kwargs = mock_secret_manager_client.call_args.kwargs
    assert call_kwargs["credentials"] == mock_credentials
    assert call_kwargs["client_options"] is None
    assert call_kwargs["client_info"].user_agent == USER_AGENT
    assert client._credentials == mock_credentials
    assert client._client == mock_secret_manager_client.return_value

  @patch("google.cloud.secretmanager.SecretManagerServiceClient")
  @patch("google.oauth2.service_account.Credentials.from_service_account_info")
  def test_init_with_service_account_json(
      self, mock_from_service_account_info, mock_secret_manager_client
  ):
    """Test initialization with service account JSON."""
    # Setup
    mock_credentials = MagicMock()
    mock_from_service_account_info.return_value = mock_credentials
    service_account_json = json.dumps({
        "type": "service_account",
        "project_id": "test-project",
        "private_key_id": "key-id",
        "private_key": "private-key",
        "client_email": "test@example.com",
    })

    # Execute
    client = SecretManagerClient(service_account_json=service_account_json)

    # Verify
    mock_from_service_account_info.assert_called_once_with(
        json.loads(service_account_json)
    )
    mock_secret_manager_client.assert_called_once()
    call_kwargs = mock_secret_manager_client.call_args.kwargs
    assert call_kwargs["credentials"] == mock_credentials
    assert call_kwargs["client_options"] is None
    assert call_kwargs["client_info"].user_agent == USER_AGENT
    assert client._credentials == mock_credentials
    assert client._client == mock_secret_manager_client.return_value

  @patch("google.cloud.secretmanager.SecretManagerServiceClient")
  def test_init_with_auth_token(self, mock_secret_manager_client):
    """Test initialization with auth token."""
    auth_token = "test-token"

    client = SecretManagerClient(auth_token=auth_token)

    mock_secret_manager_client.assert_called_once()
    call_kwargs = mock_secret_manager_client.call_args.kwargs
    assert isinstance(call_kwargs["credentials"], Credentials)
    assert call_kwargs["credentials"].token == auth_token
    assert call_kwargs["client_options"] is None
    assert call_kwargs["client_info"].user_agent == USER_AGENT
    assert isinstance(client._credentials, Credentials)
    assert client._credentials.token == auth_token
    assert client._client == mock_secret_manager_client.return_value

  @patch("google.cloud.secretmanager.SecretManagerServiceClient")
  @patch(
      "google.adk.integrations.secret_manager.secret_client.default_service_credential"
  )
  @patch(
      "google.adk.integrations.secret_manager.secret_client._mtls_utils.get_api_endpoint"
  )
  def test_init_with_location(
      self,
      mock_get_api_endpoint,
      mock_default_service_credential,
      mock_secret_manager_client,
  ):
    """Test initialization with a specific location."""
    # Setup
    mock_credentials = MagicMock()
    mock_default_service_credential.return_value = (
        mock_credentials,
        "test-project",
    )
    location = "us-central1"
    mock_get_api_endpoint.return_value = "resolved-endpoint"

    # Execute
    SecretManagerClient(location=location)

    # Verify
    mock_secret_manager_client.assert_called_once()
    call_kwargs = mock_secret_manager_client.call_args.kwargs
    assert call_kwargs["credentials"] == mock_credentials
    assert call_kwargs["client_options"] == {
        "api_endpoint": "resolved-endpoint"
    }
    assert call_kwargs["client_info"].user_agent == USER_AGENT
    mock_get_api_endpoint.assert_called_once_with(
        location,
        "secretmanager.{location}.rep.googleapis.com",
        "secretmanager.{location}.rep.mtls.googleapis.com",
    )

  @patch(
      "google.adk.integrations.secret_manager.secret_client.default_service_credential"
  )
  def test_init_with_default_credentials_error(
      self, mock_default_service_credential
  ):
    """Test initialization with default credentials that fails."""
    # Setup
    mock_default_service_credential.side_effect = Exception("Auth error")

    # Execute and verify
    with pytest.raises(
        ValueError,
        match="error occurred while trying to use default credentials",
    ):
      SecretManagerClient()

  def test_init_with_invalid_service_account_json(self):
    """Test initialization with invalid service account JSON."""
    # Execute and verify
    with pytest.raises(ValueError, match="Invalid service account JSON"):
      SecretManagerClient(service_account_json="invalid-json")

  def test_init_with_both_service_account_json_and_auth_token(self):
    """Test initialization rejects conflicting credential inputs."""
    with pytest.raises(
        ValueError,
        match=(
            "Must provide either 'service_account_json' or 'auth_token', not"
            " both."
        ),
    ):
      SecretManagerClient(
          service_account_json=json.dumps({"type": "service_account"}),
          auth_token="test-token",
      )

  @patch("google.cloud.secretmanager.SecretManagerServiceClient")
  @patch(
      "google.adk.integrations.secret_manager.secret_client.default_service_credential"
  )
  def test_get_secret(
      self, mock_default_service_credential, mock_secret_manager_client
  ):
    """Test getting a secret."""
    # Setup
    mock_credentials = MagicMock()
    mock_default_service_credential.return_value = (
        mock_credentials,
        "test-project",
    )

    mock_client = MagicMock()
    mock_secret_manager_client.return_value = mock_client
    mock_response = MagicMock()
    mock_response.payload.data.decode.return_value = "secret-value"
    mock_client.access_secret_version.return_value = mock_response

    # Execute - use default credentials instead of auth_token
    client = SecretManagerClient()
    result = client.get_secret(
        "projects/test-project/secrets/test-secret/versions/latest"
    )

    # Verify
    assert result == "secret-value"
    mock_client.access_secret_version.assert_called_once_with(
        name="projects/test-project/secrets/test-secret/versions/latest"
    )
    mock_response.payload.data.decode.assert_called_once_with("UTF-8")

  @patch("google.cloud.secretmanager.SecretManagerServiceClient")
  @patch(
      "google.adk.integrations.secret_manager.secret_client.default_service_credential"
  )
  def test_get_secret_error(
      self, mock_default_service_credential, mock_secret_manager_client
  ):
    """Test getting a secret that fails."""
    # Setup
    mock_credentials = MagicMock()
    mock_default_service_credential.return_value = (
        mock_credentials,
        "test-project",
    )

    mock_client = MagicMock()
    mock_secret_manager_client.return_value = mock_client
    mock_client.access_secret_version.side_effect = Exception("Secret error")

    # Execute and verify - use default credentials instead of auth_token
    client = SecretManagerClient()
    with pytest.raises(Exception, match="Secret error"):
      client.get_secret(
          "projects/test-project/secrets/test-secret/versions/latest"
      )