@ngocsangairvds/vsaf 4.1.8 → 4.1.9

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

@@ -1,257 +0,0 @@
-"""Unit tests for sdlc-config.env → .env migration."""
-
-from __future__ import annotations
-
-import os
-import stat
-from pathlib import Path
-
-import pytest
-
-
-# ── Fixtures ──
-
-
-@pytest.fixture
-def vds_dir(tmp_path: Path) -> Path:
-    """Create a temporary ~/.vds/ directory."""
-    d = tmp_path / ".vds"
-    d.mkdir()
-    return d
-
-
-@pytest.fixture
-def legacy_file(vds_dir: Path) -> Path:
-    """Create a populated sdlc-config.env."""
-    f = vds_dir / "sdlc-config.env"
-    f.write_text(
-        "# VDS Skill Pack — credential config\n"
-        "VDS_CONFLUENCE_TOKEN=my-confluence-pat\n"
-        "VDS_JIRA_TOKEN=my-jira-pat\n"
-        "VDS_BITBUCKET_TOKEN=my-bitbucket-pat\n"
-        "VDS_USERNAME=myuser\n"
-        "VDS_PASSWORD=mypass\n"
-        "VDS_CONFLUENCE_SPACE_DEFAULT=CEP\n"
-        "VDS_JIRA_PROJECT_DEFAULT=NTTC\n",
-        encoding="utf-8",
-    )
-    return f
-
-
-@pytest.fixture
-def target_file(vds_dir: Path) -> Path:
-    """Return path to target .env (does not create it)."""
-    return vds_dir / ".env"
-
-
-# ── Tests ──
-
-
-class TestParseEnvFile:
-    def test_basic_parse(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_text("KEY1=value1\nKEY2=value2\n")
-        result = parse_legacy_env(f)
-        assert result == {"KEY1": "value1", "KEY2": "value2"}
-
-    def test_skips_comments_and_blanks(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_text("# comment\n\nKEY=val\n  # indented comment\n")
-        result = parse_legacy_env(f)
-        assert result == {"KEY": "val"}
-
-    def test_handles_quoted_values(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_text('SINGLE=\'hello world\'\nDOUBLE="foo bar"\n')
-        result = parse_legacy_env(f)
-        assert result == {"SINGLE": "hello world", "DOUBLE": "foo bar"}
-
-    def test_handles_equals_in_value(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_text("TOKEN=abc123==\n")  # base64 padding
-        result = parse_legacy_env(f)
-        assert result == {"TOKEN": "abc123=="}
-
-    def test_handles_export_prefix(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_text("export KEY=val\n")
-        result = parse_legacy_env(f)
-        assert result == {"KEY": "val"}
-
-    def test_handles_crlf(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_bytes(b"KEY1=a\r\nKEY2=b\r\n")
-        result = parse_legacy_env(f)
-        assert result == {"KEY1": "a", "KEY2": "b"}
-
-    def test_handles_bom(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_bytes(b"\xef\xbb\xbfKEY=val\n")
-        result = parse_legacy_env(f)
-        assert result == {"KEY": "val"}
-
-    def test_nonexistent_file_returns_empty(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        result = parse_legacy_env(vds_dir / "nope.env")
-        assert result == {}
-
-    def test_skips_empty_values(self, vds_dir: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import parse_legacy_env
-
-        f = vds_dir / "test.env"
-        f.write_text("FILLED=ok\nEMPTY=\nALSO_EMPTY=  \n")
-        result = parse_legacy_env(f)
-        assert result == {"FILLED": "ok"}
-
-
-class TestMigration:
-    def test_basic_migration(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        result = migrate_sdlc_config(legacy_file, target_file)
-        assert result.migrated == [
-            "INTERNAL_CONFLUENCE_TOKEN",
-            "JIRA_TOKEN",
-            "BITBUCKET_TOKEN",
-            "VDS_USERNAME",
-            "VDS_PASSWORD",
-            "VDS_CONFLUENCE_SPACE_DEFAULT",
-            "VDS_JIRA_PROJECT_DEFAULT",
-        ]
-        assert result.skipped == []
-        assert result.warnings == []
-
-        # Verify file content
-        content = target_file.read_text(encoding="utf-8")
-        assert "INTERNAL_CONFLUENCE_TOKEN=my-confluence-pat" in content
-        assert "JIRA_TOKEN=my-jira-pat" in content
-        assert "BITBUCKET_TOKEN=my-bitbucket-pat" in content
-        assert "VDS_USERNAME=myuser" in content
-
-    def test_skips_placeholders(self, vds_dir: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        legacy = vds_dir / "sdlc-config.env"
-        legacy.write_text(
-            "VDS_CONFLUENCE_TOKEN=changeme\n"
-            "VDS_JIRA_TOKEN=<your-token>\n"
-            "VDS_BITBUCKET_TOKEN=xxx\n"
-            "VDS_USERNAME=realuser\n",
-        )
-        result = migrate_sdlc_config(legacy, target_file)
-        assert "VDS_USERNAME" in result.migrated
-        assert len(result.skipped) == 3
-        content = target_file.read_text(encoding="utf-8")
-        assert "VDS_USERNAME=realuser" in content
-        assert "INTERNAL_CONFLUENCE_TOKEN" not in content
-
-    def test_no_overwrite_existing_real_values(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        # Pre-populate target with a real value
-        target_file.write_text(
-            "INTERNAL_CONFLUENCE_TOKEN=already-set-by-user\n"
-            "JIRA_TOKEN=\n",  # empty — should be overwritten
-        )
-        result = migrate_sdlc_config(legacy_file, target_file)
-        content = target_file.read_text(encoding="utf-8")
-        # Real value preserved
-        assert "INTERNAL_CONFLUENCE_TOKEN=already-set-by-user" in content
-        # Empty value overwritten
-        assert "JIRA_TOKEN=my-jira-pat" in content
-
-    def test_overwrites_commented_var(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        target_file.write_text("# JIRA_TOKEN=old-commented-out\n")
-        result = migrate_sdlc_config(legacy_file, target_file)
-        content = target_file.read_text(encoding="utf-8")
-        assert "JIRA_TOKEN=my-jira-pat" in content
-
-    def test_idempotent(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        result1 = migrate_sdlc_config(legacy_file, target_file)
-        content_after_first = target_file.read_text(encoding="utf-8")
-        assert len(result1.migrated) == 7
-
-        result2 = migrate_sdlc_config(legacy_file, target_file)
-        content_after_second = target_file.read_text(encoding="utf-8")
-        assert result2.migrated == []
-        assert content_after_first == content_after_second
-
-    def test_warns_on_unknown_keys(self, vds_dir: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        legacy = vds_dir / "sdlc-config.env"
-        legacy.write_text("UNKNOWN_VAR=hello\nVDS_USERNAME=user\n")
-        result = migrate_sdlc_config(legacy, target_file)
-        assert "UNKNOWN_VAR" in result.warnings[0]
-        assert "VDS_USERNAME" in result.migrated
-
-    def test_creates_backup(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        target_file.write_text("EXISTING=value\n")
-        migrate_sdlc_config(legacy_file, target_file)
-        backups = list(target_file.parent.glob(".env.bak.*"))
-        assert len(backups) == 1
-        assert "EXISTING=value" in backups[0].read_text()
-
-    def test_no_backup_when_target_missing(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        assert not target_file.exists()
-        migrate_sdlc_config(legacy_file, target_file)
-        backups = list(target_file.parent.glob(".env.bak.*"))
-        assert len(backups) == 0
-
-    def test_file_permissions_0600(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        if os.name == "nt":
-            pytest.skip("Unix permissions not applicable on Windows")
-        migrate_sdlc_config(legacy_file, target_file)
-        mode = stat.S_IMODE(target_file.stat().st_mode)
-        assert mode == 0o600
-
-    def test_nonexistent_legacy_returns_skip(self, vds_dir: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        result = migrate_sdlc_config(vds_dir / "nope.env", target_file)
-        assert result.migrated == []
-        assert result.skipped == []
-        assert result.warnings == []
-        assert result.legacy_not_found is True
-
-    def test_preserves_existing_lines_and_comments(self, legacy_file: Path, target_file: Path) -> None:
-        from vds_cli_common.migrate_sdlc_config import migrate_sdlc_config
-
-        target_file.write_text(
-            "# My hand-written header\n"
-            "CUSTOM_VAR=keep-me\n"
-            "\n"
-            "# Another section\n"
-            "ANOTHER=also-keep\n",
-        )
-        migrate_sdlc_config(legacy_file, target_file)
-        content = target_file.read_text(encoding="utf-8")
-        assert "# My hand-written header" in content
-        assert "CUSTOM_VAR=keep-me" in content
-        assert "ANOTHER=also-keep" in content
-        assert "INTERNAL_CONFLUENCE_TOKEN=my-confluence-pat" in content

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

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

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

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