terminal-sherpa 0.1.0__py3-none-any.whl

test/test_exceptions.py

@@ -0,0 +1,55 @@
+"""Tests for custom exception classes."""
+
+from ask.exceptions import (
+    APIError,
+    AuthenticationError,
+    ConfigurationError,
+    RateLimitError,
+)
+
+
+def test_configuration_error():
+    """Test ConfigurationError creation."""
+    error = ConfigurationError("Config problem")
+    assert str(error) == "Config problem"
+    assert isinstance(error, Exception)
+
+
+def test_authentication_error():
+    """Test AuthenticationError creation."""
+    error = AuthenticationError("Auth failed")
+    assert str(error) == "Auth failed"
+    assert isinstance(error, Exception)
+
+
+def test_api_error():
+    """Test APIError creation."""
+    error = APIError("API failed")
+    assert str(error) == "API failed"
+    assert isinstance(error, Exception)
+
+
+def test_rate_limit_error():
+    """Test RateLimitError inheritance."""
+    error = RateLimitError("Rate limit exceeded")
+    assert str(error) == "Rate limit exceeded"
+    assert isinstance(error, APIError)
+    assert isinstance(error, Exception)
+
+
+def test_exception_hierarchy():
+    """Test exception inheritance hierarchy."""
+    # Test that RateLimitError is a subclass of APIError
+    assert issubclass(RateLimitError, APIError)
+
+    # Test that all exceptions are subclasses of Exception
+    assert issubclass(ConfigurationError, Exception)
+    assert issubclass(AuthenticationError, Exception)
+    assert issubclass(APIError, Exception)
+    assert issubclass(RateLimitError, Exception)
+
+    # Test that custom exceptions are not subclasses of each other
+    assert not issubclass(ConfigurationError, AuthenticationError)
+    assert not issubclass(AuthenticationError, ConfigurationError)
+    assert not issubclass(APIError, ConfigurationError)
+    assert not issubclass(APIError, AuthenticationError)

test/test_main.py

@@ -0,0 +1,206 @@
+"""Tests for the CLI interface."""
+
+import argparse
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from ask.exceptions import APIError, AuthenticationError, ConfigurationError
+from ask.main import (
+    configure_logging,
+    load_configuration,
+    main,
+    parse_arguments,
+    resolve_provider,
+)
+
+
+def test_parse_arguments_basic():
+    """Test basic argument parsing."""
+    with patch("sys.argv", ["ask", "list files"]):
+        args = parse_arguments()
+        assert args.prompt == "list files"
+        assert args.model is None
+        assert args.verbose is False
+
+
+def test_parse_arguments_with_model():
+    """Test --model argument."""
+    with patch("sys.argv", ["ask", "list files", "--model", "anthropic:sonnet"]):
+        args = parse_arguments()
+        assert args.prompt == "list files"
+        assert args.model == "anthropic:sonnet"
+
+
+def test_parse_arguments_with_verbose():
+    """Test --verbose flag."""
+    with patch("sys.argv", ["ask", "list files", "--verbose"]):
+        args = parse_arguments()
+        assert args.prompt == "list files"
+        assert args.verbose is True
+
+
+def test_configure_logging_verbose():
+    """Test verbose logging configuration."""
+    with patch("ask.main.logger") as mock_logger:
+        configure_logging(verbose=True)
+        mock_logger.remove.assert_called_once()
+        mock_logger.add.assert_called_once()
+
+        # Check that DEBUG level was set
+        call_args = mock_logger.add.call_args
+        assert "DEBUG" in str(call_args)
+
+
+def test_configure_logging_normal():
+    """Test normal logging configuration."""
+    with patch("ask.main.logger") as mock_logger:
+        configure_logging(verbose=False)
+        mock_logger.remove.assert_called_once()
+        mock_logger.add.assert_called_once()
+
+        # Check that ERROR level was set
+        call_args = mock_logger.add.call_args
+        assert "ERROR" in str(call_args)
+
+
+def test_load_configuration_success():
+    """Test successful config loading."""
+    mock_config = {"ask": {"default_model": "anthropic"}}
+
+    with patch("ask.config.load_config", return_value=mock_config):
+        config = load_configuration()
+        assert config == mock_config
+
+
+def test_load_configuration_error():
+    """Test configuration error handling."""
+    with patch(
+        "ask.config.load_config", side_effect=ConfigurationError("Config error")
+    ):
+        with patch("ask.main.logger") as mock_logger:
+            with pytest.raises(SystemExit):
+                load_configuration()
+            mock_logger.error.assert_called_once_with(
+                "Configuration error: Config error"
+            )
+
+
+def test_resolve_provider_with_model_arg():
+    """Test provider resolution with --model."""
+    args = argparse.Namespace(model="anthropic:sonnet")
+    config_data = {}
+    mock_provider = MagicMock()
+
+    with patch("ask.config.get_provider_config", return_value=("anthropic", {})):
+        with patch("ask.providers.get_provider", return_value=mock_provider):
+            with patch("ask.main.logger"):
+                result = resolve_provider(args, config_data)
+                assert result == mock_provider
+
+
+def test_resolve_provider_with_default_model():
+    """Test default model from config."""
+    args = argparse.Namespace(model=None)
+    config_data = {"ask": {"default_model": "anthropic"}}
+    mock_provider = MagicMock()
+
+    with patch("ask.config.get_default_model", return_value="anthropic"):
+        with patch("ask.config.get_provider_config", return_value=("anthropic", {})):
+            with patch("ask.providers.get_provider", return_value=mock_provider):
+                with patch("ask.main.logger"):
+                    result = resolve_provider(args, config_data)
+                    assert result == mock_provider
+
+
+def test_resolve_provider_with_env_fallback():
+    """Test environment variable fallback."""
+    args = argparse.Namespace(model=None)
+    config_data = {}
+    mock_provider = MagicMock()
+
+    with patch("ask.config.get_default_model", return_value=None):
+        with patch("ask.config.get_default_provider", return_value="anthropic"):
+            with patch(
+                "ask.config.get_provider_config", return_value=("anthropic", {})
+            ):
+                with patch("ask.providers.get_provider", return_value=mock_provider):
+                    with patch("ask.main.logger"):
+                        result = resolve_provider(args, config_data)
+                        assert result == mock_provider
+
+
+def test_resolve_provider_no_keys():
+    """Test when no API keys available."""
+    args = argparse.Namespace(model=None)
+    config_data = {}
+
+    with patch("ask.config.get_default_model", return_value=None):
+        with patch("ask.config.get_default_provider", return_value=None):
+            with patch("ask.main.logger") as mock_logger:
+                with pytest.raises(SystemExit):
+                    resolve_provider(args, config_data)
+                mock_logger.error.assert_called()
+
+
+def test_main_success():
+    """Test successful main function execution."""
+    mock_provider = MagicMock()
+    mock_provider.get_bash_command.return_value = "ls -la"
+
+    with patch("ask.main.parse_arguments") as mock_parse:
+        with patch("ask.main.configure_logging"):
+            with patch("ask.main.load_configuration", return_value={}):
+                with patch("ask.main.resolve_provider", return_value=mock_provider):
+                    with patch("builtins.print") as mock_print:
+                        mock_parse.return_value = argparse.Namespace(
+                            prompt="list files", model=None, verbose=False
+                        )
+
+                        main()
+
+                        mock_provider.validate_config.assert_called_once()
+                        mock_provider.get_bash_command.assert_called_once_with(
+                            "list files"
+                        )
+                        mock_print.assert_called_once_with("ls -la")
+
+
+def test_main_authentication_error():
+    """Test authentication error handling."""
+    mock_provider = MagicMock()
+    mock_provider.validate_config.side_effect = AuthenticationError("Invalid API key")
+
+    with patch("ask.main.parse_arguments") as mock_parse:
+        with patch("ask.main.configure_logging"):
+            with patch("ask.main.load_configuration", return_value={}):
+                with patch("ask.main.resolve_provider", return_value=mock_provider):
+                    with patch("ask.main.logger") as mock_logger:
+                        mock_parse.return_value = argparse.Namespace(
+                            prompt="list files", model=None, verbose=False
+                        )
+
+                        with pytest.raises(SystemExit):
+                            main()
+
+                        mock_logger.error.assert_called_once_with("Invalid API key")
+
+
+def test_main_api_error():
+    """Test API error handling."""
+    mock_provider = MagicMock()
+    mock_provider.get_bash_command.side_effect = APIError("API request failed")
+
+    with patch("ask.main.parse_arguments") as mock_parse:
+        with patch("ask.main.configure_logging"):
+            with patch("ask.main.load_configuration", return_value={}):
+                with patch("ask.main.resolve_provider", return_value=mock_provider):
+                    with patch("ask.main.logger") as mock_logger:
+                        mock_parse.return_value = argparse.Namespace(
+                            prompt="list files", model=None, verbose=False
+                        )
+
+                        with pytest.raises(SystemExit):
+                            main()
+
+                        mock_logger.error.assert_called_once_with("API request failed")

test/test_openai.py

@@ -0,0 +1,269 @@
+"""Tests for OpenAI provider."""
+
+import os
+import re
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from ask.config import SYSTEM_PROMPT
+from ask.exceptions import APIError, AuthenticationError, RateLimitError
+from ask.providers.openai import OpenAIProvider
+
+
+def test_openai_provider_init():
+    """Test provider initialization."""
+    config = {"model_name": "gpt-4o-mini"}
+    provider = OpenAIProvider(config)
+
+    assert provider.config == config
+    assert provider.client is None
+
+
+def test_validate_config_success(mock_openai_key):
+    """Test successful config validation."""
+    config = {"api_key_env": "OPENAI_API_KEY"}
+    provider = OpenAIProvider(config)
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_openai.return_value = mock_client
+
+        provider.validate_config()
+
+        assert provider.client == mock_client
+        mock_openai.assert_called_once_with(api_key="test-openai-key")
+
+
+def test_validate_config_missing_key(mock_env_vars):
+    """Test missing API key error."""
+    config = {"api_key_env": "OPENAI_API_KEY"}
+    provider = OpenAIProvider(config)
+
+    with pytest.raises(
+        AuthenticationError, match="OPENAI_API_KEY environment variable is required"
+    ):
+        provider.validate_config()
+
+
+def test_validate_config_custom_env():
+    """Test custom environment variable."""
+    config = {"api_key_env": "CUSTOM_OPENAI_KEY"}
+    provider = OpenAIProvider(config)
+
+    with patch.dict(os.environ, {"CUSTOM_OPENAI_KEY": "custom-key"}):
+        with patch("openai.OpenAI") as mock_openai:
+            mock_client = MagicMock()
+            mock_openai.return_value = mock_client
+
+            provider.validate_config()
+
+            mock_openai.assert_called_once_with(api_key="custom-key")
+
+
+def test_get_default_config():
+    """Test default configuration values."""
+    default_config = OpenAIProvider.get_default_config()
+
+    assert default_config["model_name"] == "gpt-4o-mini"
+    assert default_config["max_tokens"] == 150
+    assert default_config["api_key_env"] == "OPENAI_API_KEY"
+    assert default_config["temperature"] == 0.0
+    assert default_config["system_prompt"] == SYSTEM_PROMPT
+
+
+def test_get_bash_command_success(mock_openai_key):
+    """Test successful command generation."""
+    config = {"model_name": "gpt-4o-mini", "max_tokens": 150}
+    provider = OpenAIProvider(config)
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "ls -la"
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_client.chat.completions.create.return_value = mock_response
+        mock_openai.return_value = mock_client
+
+        result = provider.get_bash_command("list files")
+
+        assert result == "ls -la"
+        mock_client.chat.completions.create.assert_called_once_with(
+            model="gpt-4o-mini",
+            max_completion_tokens=150,
+            temperature=0.0,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": "list files"},
+            ],
+        )
+
+
+def test_get_bash_command_with_code_block(mock_openai_key):
+    """Test bash code block extraction."""
+    config = {}
+    provider = OpenAIProvider(config)
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "```bash\nls -la\n```"
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_client.chat.completions.create.return_value = mock_response
+        mock_openai.return_value = mock_client
+
+        result = provider.get_bash_command("list files")
+
+        assert result == "ls -la"
+
+
+def test_get_bash_command_without_code_block(mock_openai_key):
+    """Test plain text response."""
+    config = {}
+    provider = OpenAIProvider(config)
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "ls -la"
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_client.chat.completions.create.return_value = mock_response
+        mock_openai.return_value = mock_client
+
+        result = provider.get_bash_command("list files")
+
+        assert result == "ls -la"
+
+
+def test_get_bash_command_empty_response(mock_openai_key):
+    """Test empty API response handling."""
+    config = {}
+    provider = OpenAIProvider(config)
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = None
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_client.chat.completions.create.return_value = mock_response
+        mock_openai.return_value = mock_client
+
+        with pytest.raises(APIError, match="API returned empty response"):
+            provider.get_bash_command("list files")
+
+
+def test_get_bash_command_auto_validate(mock_openai_key):
+    """Test auto-validation behavior."""
+    config = {}
+    provider = OpenAIProvider(config)
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "ls -la"
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_client.chat.completions.create.return_value = mock_response
+        mock_openai.return_value = mock_client
+
+        # Client should be None initially
+        assert provider.client is None
+
+        result = provider.get_bash_command("list files")
+
+        # Client should be set after auto-validation
+        assert provider.client is not None
+        assert result == "ls -la"
+
+
+def test_handle_api_error_auth():
+    """Test authentication error mapping."""
+    provider = OpenAIProvider({})
+
+    with pytest.raises(AuthenticationError, match="Invalid API key"):
+        provider._handle_api_error(Exception("authentication failed"))
+
+
+def test_handle_api_error_rate_limit():
+    """Test rate limit error mapping."""
+    provider = OpenAIProvider({})
+
+    with pytest.raises(RateLimitError, match="API rate limit exceeded"):
+        provider._handle_api_error(Exception("rate limit exceeded"))
+
+
+def test_handle_api_error_quota():
+    """Test quota error mapping."""
+    provider = OpenAIProvider({})
+
+    with pytest.raises(RateLimitError, match="API rate limit exceeded"):
+        provider._handle_api_error(Exception("quota exceeded"))
+
+
+def test_handle_api_error_generic():
+    """Test generic API error mapping."""
+    provider = OpenAIProvider({})
+
+    with pytest.raises(APIError, match="API request failed"):
+        provider._handle_api_error(Exception("unexpected error"))
+
+
+def test_config_parameter_usage(mock_openai_key):
+    """Test configuration parameter usage."""
+    config = {
+        "model_name": "gpt-4o",
+        "max_tokens": 1024,
+        "temperature": 0.5,
+        "system_prompt": "Custom system prompt",
+    }
+    provider = OpenAIProvider(config)
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "custom response"
+
+    with patch("openai.OpenAI") as mock_openai:
+        mock_client = MagicMock()
+        mock_client.chat.completions.create.return_value = mock_response
+        mock_openai.return_value = mock_client
+
+        result = provider.get_bash_command("test prompt")
+
+        assert result == "custom response"
+        mock_client.chat.completions.create.assert_called_once_with(
+            model="gpt-4o",
+            max_completion_tokens=1024,
+            temperature=0.5,
+            messages=[
+                {"role": "system", "content": "Custom system prompt"},
+                {"role": "user", "content": "test prompt"},
+            ],
+        )
+
+
+def test_regex_bash_extraction():
+    """Test regex pattern for bash code extraction."""
+    _ = OpenAIProvider({})
+
+    # Test various bash code block formats
+    test_cases = [
+        ("```bash\nls -la\n```", "ls -la"),
+        ("```bash\nfind . -name '*.py'\n```", "find . -name '*.py'"),
+        ("Here is the command:\n```bash\necho 'hello'\n```", "echo 'hello'"),
+        ("plain text command", "plain text command"),
+        ("```python\nprint('hello')\n```", "```python\nprint('hello')\n```"),
+    ]
+
+    for input_text, expected in test_cases:
+        # Test the regex pattern used in the provider
+        re_match = re.search(r"```bash\n(.*)\n```", input_text)
+        if re_match:
+            result = re_match.group(1)
+        else:
+            result = input_text
+
+        assert result == expected

test/test_providers.py

@@ -0,0 +1,77 @@
+"""Tests for the provider registry."""
+
+import pytest
+
+from ask.exceptions import ConfigurationError
+from ask.providers import get_provider, list_providers, register_provider
+from ask.providers.base import ProviderInterface
+
+
+class MockProvider(ProviderInterface):
+    """Mock provider for testing."""
+
+    def get_bash_command(self, prompt: str) -> str:
+        return f"mock command for: {prompt}"
+
+    def validate_config(self) -> None:
+        pass
+
+    @classmethod
+    def get_default_config(cls) -> dict:
+        return {"mock": "config"}
+
+
+def test_register_provider():
+    """Test provider registration."""
+    # Clean up any existing registration
+    from ask.providers import _PROVIDER_REGISTRY
+
+    if "test_provider" in _PROVIDER_REGISTRY:
+        del _PROVIDER_REGISTRY["test_provider"]
+
+    register_provider("test_provider", MockProvider)
+
+    assert "test_provider" in _PROVIDER_REGISTRY
+    assert _PROVIDER_REGISTRY["test_provider"] == MockProvider
+
+
+def test_get_provider_success():
+    """Test successful provider retrieval."""
+    register_provider("test_provider", MockProvider)
+
+    provider = get_provider("test_provider", {"test": "config"})
+
+    assert isinstance(provider, MockProvider)
+    assert provider.config == {"test": "config"}
+
+
+def test_get_provider_not_found():
+    """Test unknown provider error."""
+    with pytest.raises(
+        ConfigurationError, match="Provider 'unknown_provider' not found"
+    ):
+        get_provider("unknown_provider", {})
+
+
+def test_list_providers():
+    """Test provider listing."""
+    register_provider("test_provider", MockProvider)
+
+    providers = list_providers()
+
+    assert isinstance(providers, list)
+    assert "anthropic" in providers
+    assert "openai" in providers
+
+
+def test_provider_registry_isolation():
+    """Test registry isolation between tests."""
+    from ask.providers import _PROVIDER_REGISTRY
+
+    # Register a temporary provider
+    register_provider("temp_provider", MockProvider)
+    assert "temp_provider" in _PROVIDER_REGISTRY
+
+    # Clean up
+    del _PROVIDER_REGISTRY["temp_provider"]
+    assert "temp_provider" not in _PROVIDER_REGISTRY