cleveractors-core/features/steps/credential_envvar_steps.py

"""Step definitions for env-var fallback (standalone mode).

Extracted from ``credential_provider_steps.py`` to keep that file
under 500 lines (CONTRIBUTING.md §General Principles).
"""

from __future__ import annotations

import os
from typing import Any
from unittest.mock import patch

from behave import given, then
from features.mocks.credential_helpers import make_template_renderer

from cleveractors.agents.llm import LLMAgent

# ---------------------------------------------------------------------------
# Env-var fallback (standalone mode)
# ---------------------------------------------------------------------------


@given('the OPENAI_API_KEY environment variable is set to "{api_key}"')
def step_set_openai_env_var(context: Any, api_key: str) -> None:
    """Set the OPENAI_API_KEY environment variable."""
    context.env_patch = patch.dict(os.environ, {"OPENAI_API_KEY": api_key})
    context.env_patch.start()


@given(
    "I construct an LLMAgent for openai without credentials dict "
    "and without api_key in config"
)
def step_openai_agent_no_credentials_no_api_key(context: Any) -> None:
    """Construct LLMAgent for openai in standalone mode without api_key in config."""
    config: dict[str, Any] = {"provider": "openai", "model": "gpt-3.5-turbo"}
    context.renderer = make_template_renderer()
    context.agent = LLMAgent(
        name="test_openai_agent",
        config=config,
        template_renderer=context.renderer,
    )


@then("the chat_model should be created successfully")
def step_chat_model_created_successfully(context: Any) -> None:
    """Verify the chat_model was created (no error) and is a ChatOpenAI instance."""
    from langchain_openai import ChatOpenAI

    assert context.agent._chat_model is not None, (
        "Expected chat_model to be set after property access"
    )
    assert isinstance(context.agent._chat_model, ChatOpenAI), (
        f"Expected ChatOpenAI instance, got {type(context.agent._chat_model).__name__}"
    )


@given("all API key environment variables are cleared")
def step_clear_all_api_key_env_vars(context: Any) -> None:
    """Remove all known API key environment variables."""
    # Stop any leaked patch from a prior scenario before starting a new one.
    if hasattr(context, "env_patch"):
        try:
            context.env_patch.stop()
        except Exception:
            pass

    keys_to_clear = {
        "OPENAI_API_KEY",
        "ANTHROPIC_API_KEY",
        "GOOGLE_API_KEY",
        "GOOGLEAI_API_KEY",
    }
    cleared = {k: "" for k in keys_to_clear}
    context.env_patch = patch.dict(os.environ, cleared)
    context.env_patch.start()
    for key in keys_to_clear:
        os.environ.pop(key, None)


@given(
    'I construct an LLMAgent for provider "{provider}" without credentials dict '
    "and with api_key in config"
)
def step_nonnative_agent_standalone_with_api_key(context: Any, provider: str) -> None:
    """Construct LLMAgent for non-native provider in standalone mode with api_key."""
    config: dict[str, Any] = {
        "provider": provider,
        "model": "test-model",
        "api_key": "standalone-key",
    }
    context.renderer = make_template_renderer()
    context.agent = LLMAgent(
        name="test_openai_agent",
        config=config,
        template_renderer=context.renderer,
    )


@given(
    "I construct an LLMAgent for openai without credentials dict "
    "and with api_key set to 12345"
)
def step_openai_agent_standalone_non_string_api_key(context: Any) -> None:
    """Construct LLMAgent for openai in standalone mode with non-string api_key."""
    # Clear API key env vars so the standalone path doesn't fall back to them
    keys_to_clear = {
        "OPENAI_API_KEY",
        "ANTHROPIC_API_KEY",
        "GOOGLE_API_KEY",
        "GOOGLEAI_API_KEY",
    }
    cleared = {k: "" for k in keys_to_clear}
    context.env_patch = patch.dict(os.environ, cleared)
    context.env_patch.start()
    for key in keys_to_clear:
        os.environ.pop(key, None)

    config: dict[str, Any] = {
        "provider": "openai",
        "model": "gpt-3.5-turbo",
        "api_key": 12345,
    }
    context.renderer = make_template_renderer()
    context.agent = LLMAgent(
        name="test_openai_agent",
        config=config,
        template_renderer=context.renderer,
    )


@given(
    "I construct an LLMAgent for openai without credentials dict "
    "and with whitespace-only api_key in config"
)
def step_openai_agent_standalone_whitespace_api_key(context: Any) -> None:
    """Construct LLMAgent for openai in standalone mode with whitespace-only api_key."""
    # Clear API key env vars so the standalone path doesn't fall back to them
    keys_to_clear = {
        "OPENAI_API_KEY",
        "ANTHROPIC_API_KEY",
        "GOOGLE_API_KEY",
        "GOOGLEAI_API_KEY",
    }
    cleared = {k: "" for k in keys_to_clear}
    context.env_patch = patch.dict(os.environ, cleared)
    context.env_patch.start()
    for key in keys_to_clear:
        os.environ.pop(key, None)

    config: dict[str, Any] = {
        "provider": "openai",
        "model": "gpt-3.5-turbo",
        "api_key": "   ",
    }
    context.renderer = make_template_renderer()
    context.agent = LLMAgent(
        name="test_openai_agent",
        config=config,
        template_renderer=context.renderer,
    )