@ngocsangairvds/vsaf 3.1.27 → 3.2.1

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

@@ -0,0 +1,229 @@
+"""Tests for OutputManager."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import MagicMock, patch
+
+from vds_cli_common import CLIContext, OutputManager
+from vds_cli_common.output import NullProgress
+
+
+class TestNullProgress:
+    """Tests for NullProgress class."""
+
+    def test_add_task_returns_zero(self) -> None:
+        """Test add_task returns 0."""
+        progress = NullProgress()
+        task_id = progress.add_task("Test", total=100)
+        assert task_id == 0
+
+    def test_update_is_noop(self) -> None:
+        """Test update does nothing."""
+        progress = NullProgress()
+        # Should not raise
+        progress.update(0, advance=1)
+
+    def test_context_manager(self) -> None:
+        """Test NullProgress works as context manager."""
+        with NullProgress() as progress:
+            assert isinstance(progress, NullProgress)
+
+
+class TestOutputManager:
+    """Tests for OutputManager class."""
+
+    def test_output_json_compact_in_json_only_mode(self) -> None:
+        """Test JSON output is compact in json_only mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=True)
+            out = OutputManager(ctx)
+
+            with patch("builtins.print") as mock_print:
+                out.output_json({"key": "value"})
+                mock_print.assert_called_once()
+                call_args = mock_print.call_args[0][0]
+                # Should be compact (no indentation)
+                assert call_args == '{"key": "value"}'
+
+    def test_output_json_pretty_in_normal_mode(self) -> None:
+        """Test JSON output is pretty-printed in normal mode."""
+        with patch("sys.stdout.isatty", return_value=False):
+            ctx = CLIContext.from_options(json_only=False)
+            out = OutputManager(ctx)
+
+            with patch("builtins.print") as mock_print:
+                out.output_json({"key": "value"}, pretty=True)
+                mock_print.assert_called_once()
+                call_args = mock_print.call_args[0][0]
+                # Should be pretty-printed
+                assert "  " in call_args or "\n" in call_args
+
+    def test_output_error_json_format_in_json_only_mode(self) -> None:
+        """Test error output is JSON in json_only mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=True)
+            out = OutputManager(ctx)
+
+            with patch("builtins.print") as mock_print:
+                out.output_error("Test error", hint="Test hint")
+                mock_print.assert_called_once()
+                call_args = mock_print.call_args[0][0]
+                error_obj = json.loads(call_args)
+                assert error_obj["error"] is True
+                assert error_obj["message"] == "Test error"
+                assert error_obj["hint"] == "Test hint"
+
+    def test_output_error_with_details(self) -> None:
+        """Test error output includes details."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=True)
+            out = OutputManager(ctx)
+
+            with patch("builtins.print") as mock_print:
+                out.output_error("Error", details={"key": "value"})
+                call_args = mock_print.call_args[0][0]
+                error_obj = json.loads(call_args)
+                assert error_obj["details"] == {"key": "value"}
+
+    def test_output_success_shown_when_hints_enabled(self) -> None:
+        """Test success message is shown when hints enabled."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=False, quiet=False)
+            out = OutputManager(ctx)
+
+            # Mock the console print
+            out._console = MagicMock()
+            out.output_success("Success!")
+            out._console.print.assert_called_once()
+
+    def test_output_success_hidden_in_quiet_mode(self) -> None:
+        """Test success message is hidden in quiet mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(quiet=True)
+            out = OutputManager(ctx)
+
+            out._console = MagicMock()
+            out.output_success("Success!")
+            out._console.print.assert_not_called()
+
+    def test_output_warning_shown_when_hints_enabled(self) -> None:
+        """Test warning message is shown when hints enabled."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=False, quiet=False)
+            out = OutputManager(ctx)
+
+            out._console = MagicMock()
+            out.output_warning("Warning!")
+            out._console.print.assert_called_once()
+
+    def test_output_info_shown_when_hints_enabled(self) -> None:
+        """Test info message is shown when hints enabled."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=False, quiet=False)
+            out = OutputManager(ctx)
+
+            out._console = MagicMock()
+            out.output_info("Info!")
+            out._console.print.assert_called_once()
+
+    def test_suggest_next_shown_when_hints_enabled(self) -> None:
+        """Test suggestions are shown when hints enabled."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options(json_only=False, quiet=False)
+            out = OutputManager(ctx)
+
+            out._console = MagicMock()
+            out.suggest_next(["search", "count"])
+            out._console.print.assert_called_once()
+
+    def test_suggest_next_hidden_in_json_only_mode(self) -> None:
+        """Test suggestions are hidden in json_only mode."""
+        ctx = CLIContext.from_options(json_only=True)
+        out = OutputManager(ctx)
+
+        out._console = MagicMock()
+        out.suggest_next(["search", "count"])
+        out._console.print.assert_not_called()
+
+    def test_suggest_next_empty_list(self) -> None:
+        """Test suggest_next with empty list does nothing."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options()
+            out = OutputManager(ctx)
+
+            out._console = MagicMock()
+            out.suggest_next([])
+            out._console.print.assert_not_called()
+
+    def test_spinner_shown_in_tty(self) -> None:
+        """Test spinner is shown in TTY mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options()
+            out = OutputManager(ctx)
+
+            out._err_console = MagicMock()
+            out._err_console.status = MagicMock()
+
+            with out.spinner("Testing..."):
+                pass
+
+            out._err_console.status.assert_called_once()
+
+    def test_spinner_hidden_in_pipe(self) -> None:
+        """Test spinner is hidden when piped."""
+        with patch("sys.stdout.isatty", return_value=False):
+            ctx = CLIContext.from_options()
+            out = OutputManager(ctx)
+
+            out._err_console = MagicMock()
+
+            # Should not call status
+            with out.spinner("Testing..."):
+                pass
+
+            out._err_console.status.assert_not_called()
+
+    def test_progress_returns_null_in_pipe(self) -> None:
+        """Test progress returns NullProgress when piped."""
+        with patch("sys.stdout.isatty", return_value=False):
+            ctx = CLIContext.from_options()
+            out = OutputManager(ctx)
+
+            with out.progress("Test", total=100) as progress:
+                assert isinstance(progress, NullProgress)
+
+    def test_table_returns_none_in_json_only_mode(self) -> None:
+        """Test table returns None in json_only mode."""
+        ctx = CLIContext.from_options(json_only=True)
+        out = OutputManager(ctx)
+
+        table = out.table("Test", columns=["A", "B"])
+        assert table is None
+
+    def test_table_returns_table_in_tty(self) -> None:
+        """Test table returns Rich Table in TTY mode."""
+        with patch("sys.stdout.isatty", return_value=True):
+            ctx = CLIContext.from_options()
+            out = OutputManager(ctx)
+
+            table = out.table("Test", columns=["A", "B"], rows=[["1", "2"]])
+            assert table is not None
+
+    def test_print_delegates_to_console(self) -> None:
+        """Test print delegates to console."""
+        ctx = CLIContext()
+        out = OutputManager(ctx)
+
+        out._console = MagicMock()
+        out.print("Hello")
+        out._console.print.assert_called_once_with("Hello")
+
+    def test_print_err_delegates_to_err_console(self) -> None:
+        """Test print_err delegates to err_console."""
+        ctx = CLIContext()
+        out = OutputManager(ctx)
+
+        out._err_console = MagicMock()
+        out.print_err("Error")
+        out._err_console.print.assert_called_once_with("Error")

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

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from vds_cli_common import paths
+
+
+def test_get_vds_config_root_prefers_env_override(monkeypatch, tmp_path: Path) -> None:
+    override = tmp_path / "custom-config"
+    monkeypatch.setenv("VDS_CONFIG_DIR", str(override))
+
+    assert paths.get_vds_config_root() == override.resolve()
+
+
+def test_get_default_env_paths_only_include_shared_env_path(monkeypatch, tmp_path: Path) -> None:
+    config_root = tmp_path / ".vds"
+
+    monkeypatch.delenv("VDS_ENV_FILE", raising=False)
+    monkeypatch.delenv("VDS_CONFIG_DIR", raising=False)
+    monkeypatch.setattr(paths, "_default_vds_home", lambda: config_root)
+
+    env_paths = paths.get_default_env_paths()
+
+    assert len(env_paths) == 1
+    assert env_paths[0] == config_root / ".env"
+
+
+def test_get_vds_data_root_uses_vds_home_default(monkeypatch, tmp_path: Path) -> None:
+    config_root = tmp_path / ".vds"
+
+    monkeypatch.delenv("VDS_DATA_DIR", raising=False)
+    monkeypatch.delenv("VDS_CONFIG_DIR", raising=False)
+    monkeypatch.setattr(paths, "_default_vds_home", lambda: config_root)
+
+    assert paths.get_vds_data_root() == config_root / "data"
+
+
+def test_get_vds_log_root_uses_vds_home_logs_default(monkeypatch, tmp_path: Path) -> None:
+    config_root = tmp_path / ".vds"
+
+    monkeypatch.delenv("VDS_LOG_DIR", raising=False)
+    monkeypatch.delenv("VDS_CONFIG_DIR", raising=False)
+    monkeypatch.setattr(paths, "_default_vds_home", lambda: config_root)
+
+    assert paths.get_vds_log_root() == config_root / "logs"
+
+
+def test_get_vds_config_root_uses_vds_home_default_when_no_override(monkeypatch, tmp_path: Path) -> None:
+    config_root = tmp_path / ".vds"
+
+    monkeypatch.delenv("VDS_CONFIG_DIR", raising=False)
+    monkeypatch.setattr(paths, "_default_vds_home", lambda: config_root)
+
+    assert paths.get_vds_config_root() == config_root
+
+
+def test_get_shared_env_path_prefers_env_file_override(monkeypatch, tmp_path: Path) -> None:
+    override = tmp_path / "config" / "custom.env"
+    monkeypatch.setenv("VDS_ENV_FILE", str(override))
+
+    assert paths.get_shared_env_path() == override.resolve()

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

@@ -0,0 +1,138 @@
+"""Tests for testing utilities."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from vds_cli_common import CLIContext
+from vds_cli_common.testing import (
+    capture_output,
+    create_test_context,
+    create_test_output,
+    mock_force_color_env,
+    mock_no_color_env,
+    mock_pipe,
+    mock_tty,
+)
+
+
+class TestMockTty:
+    """Tests for mock_tty context manager."""
+
+    def test_mocks_isatty_true(self) -> None:
+        """Test mock_tty makes isatty return True."""
+        with mock_tty():
+            assert sys.stdout.isatty() is True
+
+    def test_restores_after_context(self) -> None:
+        """Test mock_tty restores original after context."""
+        original = sys.stdout.isatty()
+        with mock_tty():
+            pass
+        # Should be restored (may still be True if actually TTY)
+        assert sys.stdout.isatty() == original
+
+
+class TestMockPipe:
+    """Tests for mock_pipe context manager."""
+
+    def test_mocks_isatty_false(self) -> None:
+        """Test mock_pipe makes isatty return False."""
+        with mock_pipe():
+            assert sys.stdout.isatty() is False
+
+
+class TestMockNoColorEnv:
+    """Tests for mock_no_color_env context manager."""
+
+    def test_sets_no_color_env(self) -> None:
+        """Test mock_no_color_env sets NO_COLOR."""
+        with mock_no_color_env():
+            assert os.environ.get("NO_COLOR") == "1"
+
+    def test_restores_after_context(self) -> None:
+        """Test mock_no_color_env restores env after context."""
+        original = os.environ.get("NO_COLOR")
+        with mock_no_color_env():
+            pass
+        assert os.environ.get("NO_COLOR") == original
+
+
+class TestMockForceColorEnv:
+    """Tests for mock_force_color_env context manager."""
+
+    def test_sets_force_color_env(self) -> None:
+        """Test mock_force_color_env sets FORCE_COLOR."""
+        with mock_force_color_env():
+            assert os.environ.get("FORCE_COLOR") == "1"
+
+
+class TestCaptureOutput:
+    """Tests for capture_output context manager."""
+
+    def test_captures_stdout(self) -> None:
+        """Test capture_output captures stdout."""
+        with capture_output() as captured:
+            print("Hello")
+        assert any("Hello" in s for s in captured["stdout"])
+
+    def test_captures_stderr(self) -> None:
+        """Test capture_output captures stderr."""
+        with capture_output() as captured:
+            print("Error", file=sys.stderr)
+        assert any("Error" in s for s in captured["stderr"])
+
+    def test_empty_by_default(self) -> None:
+        """Test captured is empty by default."""
+        with capture_output() as captured:
+            pass
+        assert captured["stdout"] == []
+        assert captured["stderr"] == []
+
+
+class TestCreateTestContext:
+    """Tests for create_test_context helper."""
+
+    def test_creates_context_with_defaults(self) -> None:
+        """Test creates context with default settings."""
+        ctx = create_test_context()
+        assert isinstance(ctx, CLIContext)
+        assert ctx.json_only is False
+        assert ctx.quiet is False
+
+    def test_creates_context_with_json_only(self) -> None:
+        """Test creates context with json_only."""
+        ctx = create_test_context(json_only=True)
+        assert ctx.json_only is True
+
+    def test_creates_context_with_quiet(self) -> None:
+        """Test creates context with quiet mode."""
+        ctx = create_test_context(quiet=True)
+        assert ctx.quiet is True
+
+    def test_creates_context_with_tty_mock(self) -> None:
+        """Test creates context with TTY mocked."""
+        ctx = create_test_context(is_tty=True)
+        assert ctx.is_tty is True
+
+        ctx = create_test_context(is_tty=False)
+        assert ctx.is_tty is False
+
+
+class TestCreateTestOutput:
+    """Tests for create_test_output helper."""
+
+    def test_creates_output_manager(self) -> None:
+        """Test creates OutputManager."""
+        from vds_cli_common import OutputManager
+
+        output = create_test_output()
+        assert isinstance(output, OutputManager)
+
+    def test_uses_provided_context(self) -> None:
+        """Test uses provided CLIContext."""
+        ctx = create_test_context(json_only=True)
+        output = create_test_output(ctx)
+        assert output.ctx is ctx
+        assert output.ctx.json_only is True

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

@@ -0,0 +1,64 @@
+"""Tests for version callback factory."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from vds_cli_common.version import create_version_callback, get_package_version
+
+
+class TestCreateVersionCallback:
+    """Tests for create_version_callback function."""
+
+    def test_callback_prints_version_and_exits(self) -> None:
+        """Test callback prints version and exits when value is True."""
+        callback = create_version_callback("vds-cli-common")
+
+        with patch("typer.echo") as mock_echo:
+            with pytest.raises(typer.Exit) as exc_info:
+                callback(True)
+
+            assert exc_info.value.exit_code == 0
+            mock_echo.assert_called_once()
+            call_args = mock_echo.call_args[0][0]
+            assert "vds-cli-common" in call_args
+
+    def test_callback_does_nothing_when_false(self) -> None:
+        """Test callback does nothing when value is False."""
+        callback = create_version_callback("vds-cli-common")
+
+        with patch("typer.echo") as mock_echo:
+            # Should not raise or print
+            result = callback(False)
+            assert result is None
+            mock_echo.assert_not_called()
+
+    def test_callback_handles_unknown_package(self) -> None:
+        """Test callback handles unknown package gracefully."""
+        callback = create_version_callback("nonexistent-package-xyz")
+
+        with patch("typer.echo") as mock_echo:
+            with pytest.raises(typer.Exit):
+                callback(True)
+
+            call_args = mock_echo.call_args[0][0]
+            assert "unknown" in call_args
+
+
+class TestGetPackageVersion:
+    """Tests for get_package_version function."""
+
+    def test_returns_version_for_known_package(self) -> None:
+        """Test returns version for installed package."""
+        # typer should be installed
+        version = get_package_version("typer")
+        assert version != "unknown"
+        assert "." in version  # Should have version format
+
+    def test_returns_unknown_for_missing_package(self) -> None:
+        """Test returns 'unknown' for missing package."""
+        version = get_package_version("nonexistent-package-xyz")
+        assert version == "unknown"