Python Test Doubles

from unittest.mock import Mock, AsyncMock


@pytest.fixture()
def secret_provider() -> Mock:
    provider = Mock(spec=ISecretProvider)
    provider.get_secret = Mock(return_value=None)
    return provider


@pytest.fixture()
def async_provider() -> AsyncMock:
    provider = AsyncMock(spec=ISecretProvider)
    provider.get_secret = AsyncMock(return_value=None)
    return provider

# Simple stub
provider.get_secret.return_value = "secret-value"

# Sequential returns
provider.get_secret.side_effect = ["first", "second", None]

# Conditional stub
def resolve_secret(name: str) -> str | None:
    secrets = {"/app/db": "postgres://...", "/app/key": "abc123"}
    return secrets.get(name)

provider.get_secret.side_effect = resolve_secret

real_parser = MapFileParser()
spy_parser = Mock(wraps=real_parser)

sut = EnvilderClient(provider, spy_parser)
sut.resolve_secrets(map_file)

spy_parser.parse.assert_called_once_with(map_file)

from unittest.mock import patch


@patch("boto3.client")
def Should_CallSSM_When_AwsProviderUsed(mock_boto: Mock) -> None:
    # Arrange
    mock_ssm = Mock()
    mock_boto.return_value = mock_ssm
    mock_ssm.get_parameter.return_value = {"Parameter": {"Value": "secret"}}

    # Act
    sut = AwsSsmSecretProvider()
    actual = sut.get_secret("/app/key")

    # Assert
    assert actual == "secret"
    mock_ssm.get_parameter.assert_called_once()

provider.get_secret.side_effect = ClientError(
    {"Error": {"Code": "ParameterNotFound"}}, "GetParameter"
)

provider.get_secret.assert_called_once_with("/ssm/path")
provider.get_secret.assert_called_with("/ssm/path")
logger.info.assert_called_once()

provider.get_secret.assert_not_called()
logger.error.assert_not_called()

assert provider.get_secret.call_count == 3

from unittest.mock import call

provider.get_secret.assert_has_calls([
    call("/app/db"),
    call("/app/key"),
], any_order=True)

provider.get_secret.assert_awaited_once_with("/ssm/path")
provider.get_secret.assert_awaited()
provider.get_secret.assert_not_awaited()

@pytest.fixture()
def secret_provider() -> Mock:
    provider = Mock(spec=ISecretProvider)
    provider.get_secret.return_value = None
    return provider


@pytest.fixture()
def logger() -> Mock:
    return Mock(spec=ILogger)


@pytest.fixture()
def sut(secret_provider: Mock, logger: Mock) -> EnvilderClient:
    return EnvilderClient(provider=secret_provider, logger=logger)

from dataclasses import dataclass
from typing import Optional
from uuid import UUID, uuid4


class MapFileMother:
    @staticmethod
    def create(
        provider: str = "aws",
        mappings: Optional[dict[str, str]] = None,
    ) -> ParsedMapFile:
        return ParsedMapFile(
            config=MapFileConfig(provider=provider),
            mappings=mappings or {"DB_URL": "/app/db"},
        )


class EnvilderOptionsMother:
    @staticmethod
    def create(
        provider: SecretProviderType = SecretProviderType.AWS,
        profile: Optional[str] = None,
        vault_url: Optional[str] = None,
    ) -> EnvilderOptions:
        return EnvilderOptions(
            provider=provider,
            profile=profile,
            vault_url=vault_url,
        )

# Arrange
map_file = MapFileMother.create(mappings={"API_KEY": "/prod/key"})