@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/vds_cli_common/tests/test_completers.py

@@ -0,0 +1,148 @@
+"""Tests for common completers."""
+
+from __future__ import annotations
+
+from vds_cli_common.completers import (
+    complete_index,
+    complete_log_level,
+    complete_output_format,
+    complete_project,
+    complete_server,
+    complete_time_field,
+)
+
+
+class TestCompleteIndex:
+    """Tests for complete_index function."""
+
+    def test_returns_matching_patterns(self) -> None:
+        """Test returns patterns that match incomplete input."""
+        results = complete_index("logs")
+        assert "logs-*" in results
+
+    def test_returns_all_patterns_for_empty_input(self) -> None:
+        """Test returns all patterns for empty input."""
+        results = complete_index("")
+        assert len(results) > 0
+        assert "logs-*" in results
+        assert "*" in results
+
+    def test_returns_empty_for_no_match(self) -> None:
+        """Test returns empty list for no match."""
+        results = complete_index("xyz")
+        assert results == []
+
+    def test_includes_otel_patterns(self) -> None:
+        """Test includes OpenTelemetry patterns."""
+        results = complete_index("otel")
+        assert "otel-logs-*" in results
+
+
+class TestCompleteTimeField:
+    """Tests for complete_time_field function."""
+
+    def test_returns_matching_fields(self) -> None:
+        """Test returns fields that match incomplete input."""
+        results = complete_time_field("@")
+        assert "@timestamp" in results
+
+    def test_returns_timestamp_fields(self) -> None:
+        """Test returns timestamp-related fields."""
+        results = complete_time_field("time")
+        assert "timestamp" in results
+
+    def test_returns_empty_for_no_match(self) -> None:
+        """Test returns empty list for no match."""
+        results = complete_time_field("xyz")
+        assert results == []
+
+
+class TestCompleteProject:
+    """Tests for complete_project function."""
+
+    def test_returns_matching_projects(self) -> None:
+        """Test returns projects that match incomplete input."""
+        results = complete_project("ins")
+        assert "insurance" in results
+
+    def test_case_insensitive(self) -> None:
+        """Test matching is case-insensitive."""
+        results = complete_project("LEP")
+        assert "lep" in results
+
+    def test_returns_all_projects_for_empty(self) -> None:
+        """Test returns all projects for empty input."""
+        results = complete_project("")
+        assert "lep" in results
+        assert "insurance" in results
+        assert "saving" in results
+        assert "ekyc" in results
+
+    def test_returns_empty_for_no_match(self) -> None:
+        """Test returns empty list for no match."""
+        results = complete_project("xyz")
+        assert results == []
+
+
+class TestCompleteServer:
+    """Tests for complete_server function."""
+
+    def test_returns_matching_servers(self) -> None:
+        """Test returns servers that match incomplete input."""
+        results = complete_server("int")
+        assert "internal" in results
+
+    def test_case_insensitive(self) -> None:
+        """Test matching is case-insensitive."""
+        results = complete_server("EXT")
+        assert "external" in results
+
+    def test_returns_all_servers_for_empty(self) -> None:
+        """Test returns all servers for empty input."""
+        results = complete_server("")
+        assert "internal" in results
+        assert "external" in results
+
+
+class TestCompleteOutputFormat:
+    """Tests for complete_output_format function."""
+
+    def test_returns_matching_formats(self) -> None:
+        """Test returns formats that match incomplete input."""
+        results = complete_output_format("js")
+        assert "json" in results
+
+    def test_case_insensitive(self) -> None:
+        """Test matching is case-insensitive."""
+        results = complete_output_format("JSON")
+        assert "json" in results
+
+    def test_returns_all_formats_for_empty(self) -> None:
+        """Test returns all formats for empty input."""
+        results = complete_output_format("")
+        assert "json" in results
+        assert "table" in results
+        assert "csv" in results
+
+
+class TestCompleteLogLevel:
+    """Tests for complete_log_level function."""
+
+    def test_returns_matching_levels(self) -> None:
+        """Test returns levels that match incomplete input."""
+        results = complete_log_level("ERR")
+        assert "ERROR" in results
+
+    def test_case_insensitive(self) -> None:
+        """Test matching is case-insensitive."""
+        results = complete_log_level("debug")
+        assert "DEBUG" in results
+
+    def test_returns_all_levels_for_empty(self) -> None:
+        """Test returns all levels for empty input."""
+        results = complete_log_level("")
+        assert "DEBUG" in results
+        assert "INFO" in results
+        assert "WARNING" in results
+        assert "ERROR" in results
+        assert "CRITICAL" in results

package/tools/vds-scripts/vds_cli_common/tests/test_context.py

@@ -0,0 +1,192 @@
+"""Tests for CLIContext."""
+
+from __future__ import annotations
+
+import os
+from unittest.mock import patch
+
+from vds_cli_common import CLIContext
+
+
+class TestCLIContext:
+    """Tests for CLIContext class."""
+
+    def test_default_values(self) -> None:
+        """Test default values are set correctly."""
+        ctx = CLIContext()
+        assert ctx.json_only is False
+        assert ctx.quiet is False
+        assert ctx.structured_logs is False
+        assert ctx.no_input is False
+        assert ctx.no_color is False
+        assert ctx.force_color is False
+
+    def test_from_options_factory(self) -> None:
+        """Test from_options factory method."""
+        ctx = CLIContext.from_options(
+            json_only=True,
+            quiet=True,
+            no_color=True,
+        )
+        assert ctx.json_only is True
+        assert ctx.quiet is True
+        assert ctx.no_color is True
+
+    def test_is_tty_detected_in_tty(self) -> None:
+        """Test TTY is detected when stdout is a terminal."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext()
+            assert ctx.is_tty is True
+
+    def test_is_tty_detected_in_pipe(self) -> None:
+        """Test TTY is not detected when stdout is piped."""
+        with patch("sys.stdout.isatty", return_value=False):
+            ctx = CLIContext()
+            assert ctx.is_tty is False
+
+    def test_use_color_disabled_by_json_only(self) -> None:
+        """Test json_only mode disables colors."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=True)
+            assert ctx.use_color is False
+
+    def test_use_color_disabled_by_no_color_flag(self) -> None:
+        """Test --no-color flag disables colors."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(no_color=True)
+            assert ctx.use_color is False
+
+    def test_use_color_enabled_by_force_color_flag(self) -> None:
+        """Test --color flag enables colors."""
+        with patch("sys.stdout.isatty", return_value=False):
+            ctx = CLIContext.from_options(force_color=True)
+            assert ctx.use_color is True
+
+    def test_no_color_flag_overrides_force_color(self) -> None:
+        """Test --no-color flag takes precedence over --color."""
+        ctx = CLIContext.from_options(no_color=True, force_color=True)
+        assert ctx.use_color is False
+
+    def test_no_color_env_var_respected(self) -> None:
+        """Test NO_COLOR environment variable disables colors."""
+        with patch("sys.stdout.isatty", return_value=True), patch.dict(os.environ, {"NO_COLOR": "1"}):
+            ctx = CLIContext()
+            assert ctx.use_color is False
+
+    def test_force_color_env_var_respected(self) -> None:
+        """Test FORCE_COLOR environment variable enables colors."""
+        with patch("sys.stdout.isatty", return_value=False):
+            with patch.dict(os.environ, {"FORCE_COLOR": "1"}, clear=False):
+                # Clear NO_COLOR if present
+                env = os.environ.copy()
+                env.pop("NO_COLOR", None)
+                env["FORCE_COLOR"] = "1"
+                with patch.dict(os.environ, env, clear=True):
+                    ctx = CLIContext()
+                    assert ctx.use_color is True
+
+    def test_use_rich_output_in_tty(self) -> None:
+        """Test Rich output is enabled in TTY."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext()
+            assert ctx.use_rich_output is True
+
+    def test_use_rich_output_disabled_in_pipe(self) -> None:
+        """Test Rich output is disabled when piped."""
+        with patch("sys.stdout.isatty", return_value=False):
+            ctx = CLIContext()
+            assert ctx.use_rich_output is False
+
+    def test_use_rich_output_disabled_by_json_only(self) -> None:
+        """Test Rich output is disabled in json_only mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=True)
+            assert ctx.use_rich_output is False
+
+    def test_use_spinner_in_tty(self) -> None:
+        """Test spinner is enabled in TTY."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext()
+            assert ctx.use_spinner is True
+
+    def test_use_spinner_disabled_by_quiet(self) -> None:
+        """Test spinner is disabled in quiet mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(quiet=True)
+            assert ctx.use_spinner is False
+
+    def test_use_progress_in_tty(self) -> None:
+        """Test progress is enabled in TTY."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext()
+            assert ctx.use_progress is True
+
+    def test_use_progress_disabled_by_quiet(self) -> None:
+        """Test progress is disabled in quiet mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(quiet=True)
+            assert ctx.use_progress is False
+
+    def test_show_hints_enabled_by_default(self) -> None:
+        """Test hints are shown by default."""
+        ctx = CLIContext()
+        assert ctx.show_hints is True
+
+    def test_show_hints_disabled_by_json_only(self) -> None:
+        """Test hints are hidden in json_only mode."""
+        ctx = CLIContext.from_options(json_only=True)
+        assert ctx.show_hints is False
+
+    def test_show_hints_disabled_by_quiet(self) -> None:
+        """Test hints are hidden in quiet mode."""
+        ctx = CLIContext.from_options(quiet=True)
+        assert ctx.show_hints is False
+
+    def test_console_property_returns_console(self) -> None:
+        """Test console property returns Rich Console."""
+        ctx = CLIContext()
+        console = ctx.console
+        assert console is not None
+        # Should return same instance on second call
+        assert ctx.console is console
+
+    def test_err_console_property_returns_stderr_console(self) -> None:
+        """Test err_console property returns Rich Console for stderr."""
+        ctx = CLIContext()
+        err_console = ctx.err_console
+        assert err_console is not None
+        # Should return same instance on second call
+        assert ctx.err_console is err_console
+
+    def test_from_typer_context_with_cli_context(self) -> None:
+        """Test from_typer_context extracts CLIContext."""
+        from unittest.mock import MagicMock
+
+        original_ctx = CLIContext.from_options(json_only=True)
+        typer_ctx = MagicMock()
+        typer_ctx.obj = original_ctx
+
+        result = CLIContext.from_typer_context(typer_ctx)
+        assert result is original_ctx
+
+    def test_from_typer_context_with_dict(self) -> None:
+        """Test from_typer_context extracts CLIContext from dict."""
+        from unittest.mock import MagicMock
+
+        original_ctx = CLIContext.from_options(quiet=True)
+        typer_ctx = MagicMock()
+        typer_ctx.obj = {"cli_ctx": original_ctx}
+
+        result = CLIContext.from_typer_context(typer_ctx)
+        assert result is original_ctx
+
+    def test_from_typer_context_returns_default(self) -> None:
+        """Test from_typer_context returns default when not found."""
+        from unittest.mock import MagicMock
+
+        typer_ctx = MagicMock()
+        typer_ctx.obj = None
+
+        result = CLIContext.from_typer_context(typer_ctx)
+        assert isinstance(result, CLIContext)
+        assert result.json_only is False

package/tools/vds-scripts/vds_cli_common/tests/test_env.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from vds_cli_common.env import DEFAULT_AUDIT_ENV_DEFAULTS, ensure_shared_env, load_shared_env
+from vds_cli_common.paths import get_shared_env_path
+
+
+def _write_env(path: Path, content: str) -> None:
+    path.write_text(content, encoding="utf-8")
+
+
+def test_load_shared_env_first_file_wins_when_keys_overlap(tmp_path: Path, monkeypatch) -> None:
+    primary = tmp_path / "primary.env"
+    fallback = tmp_path / "fallback.env"
+    _write_env(primary, "TOKEN=from-primary\nPRIMARY_ONLY=1\n")
+    _write_env(fallback, "TOKEN=from-fallback\nFALLBACK_ONLY=1\n")
+
+    monkeypatch.delenv("TOKEN", raising=False)
+    monkeypatch.delenv("PRIMARY_ONLY", raising=False)
+    monkeypatch.delenv("FALLBACK_ONLY", raising=False)
+
+    merged = load_shared_env(path=primary, extra_paths=(fallback,))
+
+    assert merged["TOKEN"] == "from-primary"
+    assert merged["PRIMARY_ONLY"] == "1"
+    assert merged["FALLBACK_ONLY"] == "1"
+    assert "TOKEN" in merged
+    assert "PRIMARY_ONLY" in merged
+    assert "FALLBACK_ONLY" in merged
+
+
+def test_load_shared_env_does_not_override_existing_environ_by_default(tmp_path: Path, monkeypatch) -> None:
+    env_file = tmp_path / "shared.env"
+    _write_env(env_file, "TOKEN=from-file\n")
+
+    monkeypatch.setenv("TOKEN", "from-shell")
+    load_shared_env(path=env_file)
+
+    assert os.environ["TOKEN"] == "from-shell"
+
+
+def test_load_shared_env_override_true_updates_existing_environ(tmp_path: Path, monkeypatch) -> None:
+    env_file = tmp_path / "shared.env"
+    _write_env(env_file, "TOKEN=from-file\n")
+
+    monkeypatch.setenv("TOKEN", "from-shell")
+    load_shared_env(path=env_file, override=True)
+
+    assert os.environ["TOKEN"] == "from-file"
+
+
+def test_ensure_shared_env_creates_file_with_required_defaults(tmp_path: Path) -> None:
+    env_file = tmp_path / ".vds" / ".env"
+    created = ensure_shared_env(path=env_file)
+
+    assert created == env_file
+    content = env_file.read_text(encoding="utf-8")
+    for key, value in DEFAULT_AUDIT_ENV_DEFAULTS:
+        assert f"{key}={value}" in content
+
+
+def test_ensure_shared_env_appends_missing_defaults_without_overwriting(tmp_path: Path) -> None:
+    env_file = tmp_path / ".vds" / ".env"
+    env_file.parent.mkdir(parents=True, exist_ok=True)
+    _write_env(env_file, "VDS_AUDIT_STATE_DSN=postgresql://custom/db\nTOKEN=kept\n")
+
+    ensure_shared_env(path=env_file)
+
+    values = {}
+    for line in env_file.read_text(encoding="utf-8").splitlines():
+        if "=" in line and not line.lstrip().startswith("#"):
+            key, value = line.split("=", 1)
+            values[key] = value
+    assert values["VDS_AUDIT_STATE_DSN"] == "postgresql://custom/db"
+    assert values["TOKEN"] == "kept"
+    for key, _ in DEFAULT_AUDIT_ENV_DEFAULTS:
+        assert key in values
+
+
+def test_get_shared_env_path_uses_override(monkeypatch, tmp_path: Path) -> None:
+    override = tmp_path / "envs" / "shared.env"
+    monkeypatch.setenv("VDS_ENV_FILE", str(override))
+
+    assert get_shared_env_path() == override.resolve()
+
+
+def test_load_shared_env_uses_runtime_env_file_override_without_stale_defaults(
+    monkeypatch, tmp_path: Path
+) -> None:
+    override = tmp_path / "portable" / ".env"
+    override.parent.mkdir(parents=True, exist_ok=True)
+    _write_env(override, "TOKEN=from-runtime-override\n")
+
+    monkeypatch.setenv("VDS_ENV_FILE", str(override))
+    monkeypatch.delenv("TOKEN", raising=False)
+
+    merged = load_shared_env()
+
+    assert merged["TOKEN"] == "from-runtime-override"
+    assert os.environ["TOKEN"] == "from-runtime-override"

package/tools/vds-scripts/vds_cli_common/tests/test_errors.py

@@ -0,0 +1,186 @@
+"""Tests for ErrorHandler and ExitCodes."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+import typer
+
+from vds_cli_common import CLIContext, ErrorHandler, ExitCodes, OutputManager
+
+
+class TestExitCodes:
+    """Tests for ExitCodes enum."""
+
+    def test_success_is_zero(self) -> None:
+        """Test SUCCESS is 0."""
+        assert ExitCodes.SUCCESS == 0
+
+    def test_general_error_is_one(self) -> None:
+        """Test GENERAL_ERROR is 1."""
+        assert ExitCodes.GENERAL_ERROR == 1
+
+    def test_all_codes_are_integers(self) -> None:
+        """Test all exit codes are integers."""
+        for code in ExitCodes:
+            assert isinstance(code.value, int)
+
+    def test_codes_are_unique(self) -> None:
+        """Test all exit codes are unique."""
+        values = [code.value for code in ExitCodes]
+        assert len(values) == len(set(values))
+
+
+class TestErrorHandler:
+    """Tests for ErrorHandler class."""
+
+    @pytest.fixture
+    def handler(self) -> ErrorHandler:
+        """Create an ErrorHandler for testing."""
+        ctx = CLIContext.from_options(json_only=True)
+        output = OutputManager(ctx)
+        return ErrorHandler(output, valid_commands=["search", "count", "ping", "export"])
+
+    def test_suggest_command_finds_match(self, handler: ErrorHandler) -> None:
+        """Test suggest_command finds close matches."""
+        assert handler.suggest_command("serch") == "search"
+        assert handler.suggest_command("cout") == "count"
+        assert handler.suggest_command("pimg") == "ping"
+
+    def test_suggest_command_no_match(self, handler: ErrorHandler) -> None:
+        """Test suggest_command returns None for no match."""
+        assert handler.suggest_command("xyz") is None
+        assert handler.suggest_command("foo") is None
+
+    def test_suggest_command_exact_match(self, handler: ErrorHandler) -> None:
+        """Test suggest_command works with exact match."""
+        assert handler.suggest_command("search") == "search"
+
+    def test_suggest_command_custom_cutoff(self, handler: ErrorHandler) -> None:
+        """Test suggest_command respects cutoff parameter."""
+        # With high cutoff, weak matches should fail
+        assert handler.suggest_command("s", cutoff=0.9) is None
+        # With low cutoff, weak matches might succeed
+        result = handler.suggest_command("sear", cutoff=0.5)
+        assert result is not None
+
+    def test_handle_unknown_command_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_unknown_command exits with USAGE_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_unknown_command("foo")
+        assert exc_info.value.exit_code == ExitCodes.USAGE_ERROR
+
+    def test_handle_unknown_command_with_suggestion(self, handler: ErrorHandler) -> None:
+        """Test handle_unknown_command provides suggestion."""
+        handler.output = MagicMock()
+        with pytest.raises(typer.Exit):
+            handler.handle_unknown_command("serch")
+        # Should have called output_error
+        handler.output.output_error.assert_called_once()
+
+    def test_handle_config_error_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_config_error exits with CONFIG_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_config_error("Missing config")
+        assert exc_info.value.exit_code == ExitCodes.CONFIG_ERROR
+
+    def test_handle_config_error_with_missing_vars(self, handler: ErrorHandler) -> None:
+        """Test handle_config_error includes missing variables."""
+        handler.output = MagicMock()
+        with pytest.raises(typer.Exit):
+            handler.handle_config_error(
+                "Config error",
+                missing_vars=["VAR1", "VAR2"],
+            )
+        handler.output.output_error.assert_called_once()
+        call_kwargs = handler.output.output_error.call_args[1]
+        assert "missing_variables" in call_kwargs["details"]
+
+    def test_handle_auth_error_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_auth_error exits with AUTH_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_auth_error("Invalid credentials")
+        assert exc_info.value.exit_code == ExitCodes.AUTH_ERROR
+
+    def test_handle_permission_error_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_permission_error exits with PERMISSION_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_permission_error("Access denied")
+        assert exc_info.value.exit_code == ExitCodes.PERMISSION_ERROR
+
+    def test_handle_permission_error_with_roles(self, handler: ErrorHandler) -> None:
+        """Test handle_permission_error includes role information."""
+        handler.output = MagicMock()
+        with pytest.raises(typer.Exit):
+            handler.handle_permission_error(
+                "Access denied",
+                required_role="admin",
+                current_role="viewer",
+            )
+        call_kwargs = handler.output.output_error.call_args[1]
+        assert call_kwargs["details"]["required_role"] == "admin"
+        assert call_kwargs["details"]["current_role"] == "viewer"
+
+    def test_handle_network_error_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_network_error exits with NETWORK_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_network_error("Connection failed")
+        assert exc_info.value.exit_code == ExitCodes.NETWORK_ERROR
+
+    def test_handle_network_error_with_url(self, handler: ErrorHandler) -> None:
+        """Test handle_network_error includes URL."""
+        handler.output = MagicMock()
+        with pytest.raises(typer.Exit):
+            handler.handle_network_error(
+                "Connection failed",
+                url="http://example.com",
+            )
+        call_kwargs = handler.output.output_error.call_args[1]
+        assert call_kwargs["details"]["url"] == "http://example.com"
+
+    def test_handle_not_found_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_not_found exits with NOT_FOUND_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_not_found("Index", "logs-*")
+        assert exc_info.value.exit_code == ExitCodes.NOT_FOUND_ERROR
+
+    def test_handle_validation_error_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_validation_error exits with VALIDATION_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_validation_error("Invalid input")
+        assert exc_info.value.exit_code == ExitCodes.VALIDATION_ERROR
+
+    def test_handle_validation_error_with_field(self, handler: ErrorHandler) -> None:
+        """Test handle_validation_error includes field information."""
+        handler.output = MagicMock()
+        with pytest.raises(typer.Exit):
+            handler.handle_validation_error(
+                "Invalid input",
+                field="index",
+                expected="string",
+            )
+        call_kwargs = handler.output.output_error.call_args[1]
+        assert call_kwargs["details"]["field"] == "index"
+        assert call_kwargs["details"]["expected"] == "string"
+
+    def test_handle_general_error_exits(self, handler: ErrorHandler) -> None:
+        """Test handle_general_error exits with GENERAL_ERROR."""
+        with pytest.raises(typer.Exit) as exc_info:
+            handler.handle_general_error("Something went wrong")
+        assert exc_info.value.exit_code == ExitCodes.GENERAL_ERROR
+
+    def test_handle_general_error_with_hint(self, handler: ErrorHandler) -> None:
+        """Test handle_general_error includes hint."""
+        handler.output = MagicMock()
+        with pytest.raises(typer.Exit):
+            handler.handle_general_error(
+                "Error",
+                hint="Try again",
+                details={"key": "value"},
+            )
+        handler.output.output_error.assert_called_once_with(
+            "Error",
+            hint="Try again",
+            details={"key": "value"},
+        )