@ngocsangairvds/vsaf 4.1.7 → 4.1.9

package/skills/vds-skill/vds-scripts/vds_cli_common/tests/test_app.py

@@ -1,126 +0,0 @@
-"""Tests for vds_cli_common.app — TSK-7.16."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any
-from unittest.mock import MagicMock
-
-import typer
-from typer.testing import CliRunner
-
-from vds_cli_common import CLIContext, make_vds_app
-
-runner = CliRunner()
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_app(*, settings_factory: Callable[[], Any] | None = None) -> tuple[typer.Typer, dict]:
-    """Create app + captured dict + a registered dummy command."""
-    captured: dict = {}
-    factory = settings_factory or (lambda: None)
-    app = make_vds_app(name="tst", help="test app", settings_factory=factory)
-
-    @app.command()
-    def cmd(ctx: typer.Context) -> None:
-        captured["obj"] = ctx.obj
-
-    return app, captured
-
-
-# ---------------------------------------------------------------------------
-# Context construction
-# ---------------------------------------------------------------------------
-
-
-def test_cli_context_created_on_invoke() -> None:
-    """ctx.obj['cli_ctx'] is a CLIContext after app invocation."""
-    app, captured = _make_app()
-    runner.invoke(app, ["cmd"])
-    assert isinstance(captured["obj"]["cli_ctx"], CLIContext)
-
-
-# ---------------------------------------------------------------------------
-# Flag propagation
-# ---------------------------------------------------------------------------
-
-
-def test_json_flag_propagates() -> None:
-    """--json sets json_only=True on the CLIContext."""
-    app, captured = _make_app()
-    runner.invoke(app, ["--json", "cmd"])
-    assert captured["obj"]["cli_ctx"].json_only is True
-
-
-def test_quiet_flag_propagates() -> None:
-    """--quiet sets quiet=True on the CLIContext."""
-    app, captured = _make_app()
-    runner.invoke(app, ["--quiet", "cmd"])
-    assert captured["obj"]["cli_ctx"].quiet is True
-
-
-def test_verbose_flag_sets_structured_logs() -> None:
-    """--verbose sets structured_logs=True on the CLIContext."""
-    app, captured = _make_app()
-    runner.invoke(app, ["--verbose", "cmd"])
-    assert captured["obj"]["cli_ctx"].structured_logs is True
-
-
-def test_no_color_flag_propagates() -> None:
-    """--no-color sets no_color=True on the CLIContext."""
-    app, captured = _make_app()
-    runner.invoke(app, ["--no-color", "cmd"])
-    assert captured["obj"]["cli_ctx"].no_color is True
-
-
-# ---------------------------------------------------------------------------
-# settings_factory lifecycle
-# ---------------------------------------------------------------------------
-
-
-def test_settings_factory_called_once_per_invocation() -> None:
-    """settings_factory is called exactly once per command run."""
-    factory = MagicMock(return_value=None)
-    app, _ = _make_app(settings_factory=factory)
-    runner.invoke(app, ["cmd"])
-    factory.assert_called_once()
-
-
-def test_no_shared_state_between_invocations() -> None:
-    """Each invocation yields a fresh CLIContext — no module-level state bleed."""
-    app, captured = _make_app()
-    runner.invoke(app, ["--json", "cmd"])
-    first = captured["obj"]["cli_ctx"]
-    runner.invoke(app, ["cmd"])
-    second = captured["obj"]["cli_ctx"]
-    assert first is not second
-    assert second.json_only is False  # fresh context, not contaminated
-
-
-# ---------------------------------------------------------------------------
-# Return type
-# ---------------------------------------------------------------------------
-
-
-def test_app_returns_typer_instance() -> None:
-    """make_vds_app returns a typer.Typer instance."""
-    app = make_vds_app(name="x", help="x", settings_factory=lambda: None)
-    assert isinstance(app, typer.Typer)
-
-
-def test_make_vds_app_docstring_marks_factory_as_new_cli_only() -> None:
-    """Factory docs state the Phase 8 new-CLI-only guidance."""
-    doc = make_vds_app.__doc__ or ""
-    assert "new CLIs only" in doc
-    assert "Existing CLIs should" in doc
-
-
-def test_make_vds_app_docstring_points_to_bitbucket_pattern() -> None:
-    """Factory docs reference the direct Typer compatibility pattern."""
-    doc = make_vds_app.__doc__ or ""
-    assert "bitbucket_orchestrator/cli.py" in doc
-    assert "direct `typer.Typer()`" in doc

package/skills/vds-skill/vds-scripts/vds_cli_common/tests/test_completers.py

@@ -1,148 +0,0 @@
-"""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/skills/vds-skill/vds-scripts/vds_cli_common/tests/test_context.py

@@ -1,192 +0,0 @@
-"""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