add complete testsuite

Author: yrobla

tests/test_cli.py

@@ -1,5 +1,6 @@
 """Tests for the server module."""
 
+import os
 from unittest.mock import MagicMock, patch, AsyncMock
 
 import pytest
@@ -16,6 +17,7 @@
 from src.codegate.codegate_logging import LogLevel, LogFormat
 from uvicorn.config import Config as UvicornConfig
 from click.testing import CliRunner
+from pathlib import Path
 
 
 @pytest.fixture
@@ -277,7 +279,8 @@ def test_serve_custom_options(cli_runner):
 
         # Check if Config object attributes match the expected values
         for key, expected_value in expected_values.items():
-            assert getattr(config_arg, key) == expected_value, f"{key} does not match expected value"
+            assert getattr(config_arg, key) == expected_value, \
+                f"{key} does not match expected value"
 
 
 def test_serve_invalid_port(cli_runner):
@@ -326,7 +329,7 @@ def test_serve_with_config_file(cli_runner, temp_config_file):
 
         # Validate that run_servers was called with the expected configuration
         mock_run.assert_called_once()
-        config_arg = mock_run.call_args[0][0]  # Assuming Config object is the first positional argument
+        config_arg = mock_run.call_args[0][0]
 
         # Define expected values based on the temp_config_file content
         expected_values = {
@@ -338,6 +341,160 @@ def test_serve_with_config_file(cli_runner, temp_config_file):
         }
 
         # Check if passed arguments match the expected values
+        for key, expected_value in expected_values.items():
+            assert getattr(config_arg, key) == expected_value, \
+                f"{key} does not match expected value"
+
+
+def test_serve_with_nonexistent_config_file(cli_runner: CliRunner) -> None:
+    """Test serve command with nonexistent config file."""
+    result = cli_runner.invoke(cli, ["serve", "--config", "nonexistent.yaml"])
+    assert result.exit_code == 2
+    assert "does not exist" in result.output
+
+
+def test_serve_priority_resolution(cli_runner: CliRunner, temp_config_file: Path) -> None:
+    """Test serve command respects configuration priority."""
+    # Set up environment variables and ensure they get cleaned up after the test
+    with patch.dict(os.environ, {'LOG_LEVEL': 'INFO', 'PORT': '9999'}, clear=True), \
+         patch('src.codegate.cli.run_servers') as mock_run, \
+         patch('src.codegate.cli.structlog.get_logger') as mock_logging, \
+         patch('src.codegate.cli.setup_logging') as mock_setup_logging:
+        # Set up mock logger
+        logger_instance = MagicMock()
+        mock_logging.return_value = logger_instance
+
+        # Execute CLI command with specific options overriding environment and config file settings
+        result = cli_runner.invoke(
+            cli,
+            [
+                "serve",
+                "--config",
+                str(temp_config_file),
+                "--port",
+                "8080",
+                "--host",
+                "example.com",
+                "--log-level",
+                "ERROR",
+                "--log-format",
+                "TEXT",
+                "--certs-dir",
+                "./cli-certs",
+                "--ca-cert",
+                "cli-ca.crt",
+                "--ca-key",
+                "cli-ca.key",
+                "--server-cert",
+                "cli-server.crt",
+                "--server-key",
+                "cli-server.key",
+            ],
+        )
+
+        # Check the result of the command
+        assert result.exit_code == 0
+
+        # Ensure logging setup was called with the highest priority settings (CLI arguments)
+        mock_setup_logging.assert_called_once_with('ERROR', 'TEXT')
+        mock_logging.assert_called_with("codegate")
+
+        # Verify that the run_servers was called with the overridden settings
+        config_arg = mock_run.call_args[0][0]  # Assuming Config is the first positional arg
+
+        expected_values = {
+            "port": 8080,
+            "host": "example.com",
+            "log_level": 'ERROR',
+            "log_format": 'TEXT',
+            "certs_dir": "./cli-certs",
+            "ca_cert": "cli-ca.crt",
+            "ca_key": "cli-ca.key",
+            "server_cert": "cli-server.crt",
+            "server_key": "cli-server.key",
+        }
+
+        # Verify if Config object attributes match the expected values from CLI arguments
         for key, expected_value in expected_values.items():
             assert getattr(config_arg, key) == expected_value, f"{key} does not match expected value"
 
+
+def test_serve_certificate_options(cli_runner: CliRunner) -> None:
+    """Test serve command with certificate options."""
+    with patch('src.codegate.cli.run_servers') as mock_run, \
+         patch('src.codegate.cli.structlog.get_logger') as mock_logging, \
+         patch('src.codegate.cli.setup_logging') as mock_setup_logging:
+        # Set up mock logger
+        logger_instance = MagicMock()
+        mock_logging.return_value = logger_instance
+
+        # Execute CLI command with certificate options
+        result = cli_runner.invoke(
+            cli,
+            [
+                "serve",
+                "--certs-dir",
+                "./custom-certs",
+                "--ca-cert",
+                "custom-ca.crt",
+                "--ca-key",
+                "custom-ca.key",
+                "--server-cert",
+                "custom-server.crt",
+                "--server-key",
+                "custom-server.key",
+            ],
+        )
+
+        # Check the result of the command
+        assert result.exit_code == 0
+
+        # Ensure logging setup was called with expected arguments
+        mock_setup_logging.assert_called_once_with('INFO', 'JSON')
+        mock_logging.assert_called_with("codegate")
+
+        # Verify that run_servers was called with the provided certificate options
+        config_arg = mock_run.call_args[0][0]  # Assuming Config is the first positional arg
+
+        expected_values = {
+            "certs_dir": "./custom-certs",
+            "ca_cert": "custom-ca.crt",
+            "ca_key": "custom-ca.key",
+            "server_cert": "custom-server.crt",
+            "server_key": "custom-server.key",
+        }
+
+        # Check if Config object attributes match the expected values
+        for key, expected_value in expected_values.items():
+            assert getattr(config_arg, key) == expected_value, f"{key} does not match expected value"
+
+
+def test_main_function() -> None:
+    """Test main function."""
+    with patch("sys.argv", ["cli"]), patch("codegate.cli.cli") as mock_cli:
+        from codegate.cli import main
+        main()
+        mock_cli.assert_called_once()
+
+
+@pytest.fixture
+def mock_uvicorn_server():
+    mock_config = MagicMock()  # Setup the configuration mock
+    mock_server = MagicMock(spec=UvicornServer)
+    mock_server.shutdown = AsyncMock()  # Ensure shutdown is an async mock
+
+    uvicorn_server = UvicornServer(config=mock_config, server=mock_server)
+    return uvicorn_server
+
+
+@pytest.mark.asyncio
+async def test_uvicorn_server_cleanup(mock_uvicorn_server):
+    with patch("asyncio.get_running_loop"), \
+         patch.object(mock_uvicorn_server.server, 'shutdown', AsyncMock()):
+        # Mock the loop or other components as needed
+
+        # Start the server or trigger the condition you want to test
+        await mock_uvicorn_server.cleanup()  # This should now complete without error
+
+        # Verify that the shutdown was called
+        mock_uvicorn_server.server.shutdown.assert_awaited_once()