@ngocsangairvds/vsaf 4.1.7 → 4.1.9

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_ecosystem_cli_dashboard_rendering.py

@@ -1,143 +0,0 @@
-"""CLI dashboard rendering tests (TSK-P4-3.5, Phase 4 Wave 3).
-
-Four tests validating Wave 3.1-3.4 render fixes:
-  1. Column folding: long timestamps fold at 80 columns, not truncate
-  2. Single-point sparkline: N<3 → "trend insufficient" hint
-  3. Empty-state uniformity: all three commands route through _render_empty_state
-  4. NULL dim-grey: None values render as "[dim]—[/dim]" sentinel
-
-All tests use `rich.Console(record=True)` + `console.export_text()` for
-deterministic render output verification. Database calls are patched out
-so tests never require a live Postgres connection.
-"""
-
-from __future__ import annotations
-
-from datetime import UTC, datetime, timedelta
-from unittest.mock import MagicMock, patch
-
-import pytest
-from rich.console import Console
-from rich.terminal_theme import MONOKAI
-from vds_cli.ecosystem.report import (
-    NULL_CELL,
-    SPARKLINE_MIN_POINTS,
-    _fmt_nullable,
-    _render_empty_state,
-    _validate_days,
-    render_sparkline_with_hint,
-)
-
-FROZEN_NOW = datetime(2026, 5, 2, 12, 0, 0, tzinfo=UTC)
-
-
-class TestColumnFolding:
-    """TSK-P4-3.1/3.5: long-column folding in history table."""
-
-    def test_fold_does_not_truncate_to_ellipsis(self) -> None:
-        """Passing --no-full (default) uses overflow='fold', not default 'fold_on_edge'."""
-        # Invoke via the console-record approach — check that overflow="fold" is set.
-        # We test indirectly: _fmt_nullable on long strings + verify the table built.
-        long_path = "/very/long/path/to/reports/ecosystem_report_2026_05_02.json"
-        result = _fmt_nullable(long_path)
-        # Strings pass through unchanged (caller table handles overflow)
-        assert result == long_path
-
-    def test_null_cell_renders_dim_em_dash(self) -> None:
-        """None → '[dim]—[/dim]' sentinel (Wave 3.4)."""
-        result = _fmt_nullable(None)
-        assert result == NULL_CELL
-        assert "[dim]" in result
-        assert "[/dim]" in result
-
-    def test_zero_value_is_not_none(self) -> None:
-        """0 is a real value, not NULL — renders as '0'."""
-        result = _fmt_nullable(0)
-        assert result == "0"
-        assert result != NULL_CELL
-
-
-class TestSparklineSinglePoint:
-    """TSK-P4-3.2/3.5: N < 3 → trend insufficient hint."""
-
-    def test_single_value_shows_insufficient_hint(self) -> None:
-        """One value → sparkline + '(trend insufficient: N=1, need ≥3)'."""
-        result = render_sparkline_with_hint([42.0])
-
-        assert "trend insufficient" in result
-        assert "N=1" in result
-        assert "need ≥3" in result
-        # Single value still renders its bar character
-        assert "▁" in result or "▂" in result or "▃" in result
-
-    def test_two_values_shows_insufficient_hint(self) -> None:
-        """Two values → hint present, N=2."""
-        result = render_sparkline_with_hint([10.0, 30.0])
-
-        assert "trend insufficient" in result
-        assert "N=2" in result
-        assert "need ≥3" in result
-
-    def test_three_values_no_hint(self) -> None:
-        """Three values → no hint, clean sparkline."""
-        result = render_sparkline_with_hint([10.0, 20.0, 15.0])
-
-        assert "trend insufficient" not in result
-        # Should contain only sparkline bar characters (at least one)
-        assert any(c in result for c in "▁▂▃▄▅▆▇█")
-
-    def test_empty_list_returns_insufficient_hint(self) -> None:
-        """Empty list → 'trend insufficient: N=0' hint (no crash)."""
-        result = render_sparkline_with_hint([])
-
-        assert "trend insufficient" in result
-        assert "N=0" in result
-        assert "need ≥3" in result
-
-
-class TestEmptyStateUniformity:
-    """TSK-P4-3.3/3.5: all commands route through the same empty-state banner."""
-
-    def test_empty_state_banner_printed(self) -> None:
-        """_render_empty_state emits the canonical '[yellow]No data available[/yellow]'."""
-        console = Console(record=True, width=80, color_system="standard")
-
-        with patch("vds_cli.ecosystem.report.console", console):
-            _render_empty_state()
-
-        text = console.export_text()
-        assert "No data available" in text
-
-    def test_empty_state_with_suffix(self) -> None:
-        """_render_empty_state with suffix appends the metric hint."""
-        console = Console(record=True, width=80, color_system="standard")
-
-        with patch("vds_cli.ecosystem.report.console", console):
-            _render_empty_state(" for metric 'health_score'")
-
-        text = console.export_text()
-        assert "No data available" in text
-        assert "health_score" in text
-
-
-class TestValidateDays:
-    """Boundary tests for --days validation."""
-
-    def test_days_must_be_positive_integer(self) -> None:
-        """Non-positive raises BadParameter."""
-        from typer import BadParameter
-
-        with pytest.raises(BadParameter, match="positive"):
-            _validate_days(0)
-
-    def test_negative_days_raises(self) -> None:
-        """Negative days raises BadParameter."""
-        from typer import BadParameter
-
-        with pytest.raises(BadParameter, match="positive"):
-            _validate_days(-5)
-
-    def test_positive_days_passes(self) -> None:
-        """Valid positive int returns the same value."""
-        result = _validate_days(30)
-        assert result == 30

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_ecosystem_docs.py

@@ -1,63 +0,0 @@
-"""Tests for ecosystem_docs module."""
-
-from vds_cli.ecosystem_docs import discover_repos, scan_repo_docs
-
-
-class TestDiscoverRepos:
-    def test_no_repos_found(self, tmp_path):
-        found = discover_repos(tmp_path)
-        assert found == []
-
-    def test_finds_repos_with_agents_md(self, tmp_path):
-        for name in ["vds-scripts", "vds-skills"]:
-            repo = tmp_path / name
-            repo.mkdir()
-            (repo / "AGENTS.md").write_text("# Test")
-        found = discover_repos(tmp_path)
-        assert len(found) == 2
-        assert {f.name for f in found} == {"vds-scripts", "vds-skills"}
-
-
-class TestScanRepoDocs:
-    def test_empty_repo(self, tmp_path):
-        entries = scan_repo_docs(tmp_path)
-        assert entries == []
-
-    def test_finds_doc_with_diataxis_header(self, tmp_path):
-        docs = tmp_path / "docs" / "agents"
-        docs.mkdir(parents=True)
-        (docs / "test.md").write_text("# Test Doc\n<!-- diátaxis: how-to -->\n")
-        entries = scan_repo_docs(tmp_path)
-        assert len(entries) == 1
-        assert entries[0].quadrant == "how-to"
-        assert entries[0].title == "Test Doc"
-
-
-    def test_finds_doc_with_yaml_frontmatter_diátaxis(self, tmp_path):
-        """Phase 180 docs use YAML frontmatter instead of HTML comments."""
-        docs = tmp_path / "docs" / "agents" / "explanation"
-        docs.mkdir(parents=True)
-        (tmp_path / "docs" / "AGENTS.md").write_text("# AGENTS", encoding="utf-8")
-        (docs / "whats-new.md").write_text(
-            "---\n"
-            "diátaxis: explanation\n"
-            "phase_ref: 180\n"
-            "---\n\n"
-            "# New Changes\n\nRecent changes.\n",
-            encoding="utf-8",
-        )
-        entries = scan_repo_docs(tmp_path)
-        assert len(entries) == 1
-        assert entries[0].quadrant == "explanation"
-        assert entries[0].title == "New Changes"
-
-    def test_title_falls_back_to_stem_when_no_heading(self, tmp_path):
-        """Docs with neither YAML frontmatter nor H1 use filename stem."""
-        docs = tmp_path / "docs" / "agents" / "reference"
-        docs.mkdir(parents=True)
-        (tmp_path / "docs" / "AGENTS.md").write_text("# AGENTS", encoding="utf-8")
-        (docs / "bare-doc.md").write_text("Just body text.\n", encoding="utf-8")
-        entries = scan_repo_docs(tmp_path)
-        assert len(entries) == 1
-        assert entries[0].title == "Bare Doc"
-        assert entries[0].quadrant == "uncategorized"

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_env.py

@@ -1,85 +0,0 @@
-"""Unit tests for environment management."""
-
-import os
-from pathlib import Path
-
-from vds_cli.env import VDSSettings, load_environment
-from vds_cli_common.paths import get_shared_env_path
-
-
-def test_vds_settings_instantiation() -> None:
-    """Test VDSSettings can be instantiated."""
-    # Note: This test verifies the class can be instantiated
-    # Actual values depend on environment and ~/.vds/.env file
-    settings = VDSSettings()
-    assert isinstance(settings, VDSSettings)
-    # Verify all expected attributes exist
-    assert hasattr(settings, "vds_username")
-    assert hasattr(settings, "vds_password")
-    assert hasattr(settings, "bitbucket_access_token")
-    assert hasattr(settings, "internal_confluence_token")
-    assert hasattr(settings, "external_confluence_token")
-
-
-def test_vds_settings_with_env_file(mock_env_file: Path, mock_home_dir: Path) -> None:
-    """Test VDSSettings can load from environment file."""
-    # Note: pydantic-settings reads from both env file and environment variables
-    # This test verifies the class can be instantiated with a file present
-    settings = VDSSettings()
-    assert isinstance(settings, VDSSettings)
-    # Values may come from file or environment - just verify structure
-    assert hasattr(settings, "vds_username")
-
-
-def test_load_environment() -> None:
-    """Test load_environment function."""
-    settings = load_environment()
-    assert isinstance(settings, VDSSettings)
-    assert hasattr(settings, "vds_username")
-
-
-def test_load_environment_returns_settings() -> None:
-    """Test load_environment returns VDSSettings instance."""
-    settings = load_environment()
-    assert isinstance(settings, VDSSettings)
-    # Verify it has all expected attributes
-    assert hasattr(settings, "vds_username")
-    assert hasattr(settings, "bitbucket_access_token")
-
-
-def test_shared_env_path_available() -> None:
-    """Test shared env path helper returns a Path."""
-    path = get_shared_env_path()
-    assert isinstance(path, Path)
-    assert path.name == ".env"
-
-
-def test_load_environment_prefers_existing_shell_environment(tmp_path: Path, monkeypatch) -> None:
-    """Shell environment should win over values loaded from the shared env file."""
-    env_file = tmp_path / "config" / ".env"
-    env_file.parent.mkdir(parents=True, exist_ok=True)
-    env_file.write_text("VDS_USERNAME=from-file\n", encoding="utf-8")
-
-    monkeypatch.setenv("VDS_ENV_FILE", str(env_file))
-    monkeypatch.setenv("VDS_USERNAME", "from-shell")
-
-    settings = load_environment()
-
-    assert settings.vds_username == "from-shell"
-    assert os.environ["VDS_USERNAME"] == "from-shell"
-
-
-def test_load_environment_uses_shared_env_file_override(tmp_path: Path, monkeypatch) -> None:
-    """Configured shared env file should feed VDS settings when shell values are absent."""
-    env_file = tmp_path / "portable-config" / ".env"
-    env_file.parent.mkdir(parents=True, exist_ok=True)
-    env_file.write_text("VDS_USERNAME=portable-user\nVDS_PASSWORD=portable-pass\n", encoding="utf-8")
-
-    monkeypatch.setenv("VDS_ENV_FILE", str(env_file))
-    monkeypatch.delenv("VDS_USERNAME", raising=False)
-    monkeypatch.delenv("VDS_PASSWORD", raising=False)
-
-    settings = load_environment()
-
-    assert settings.vds_username == "portable-user"
-    assert settings.vds_password == "portable-pass"

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_freshness_report.py

@@ -1,125 +0,0 @@
-"""Tests for docs.freshness.report module."""
-
-from __future__ import annotations
-
-import datetime
-from pathlib import Path
-
-from vds_cli.docs.freshness.report import (
-    FreshnessRow,
-    _file_mtime,
-    _has_draft_marker,
-    classify,
-)
-
-
-def _make_row(
-    vi_path: str = "docs/vi/test.md",
-    en_path: str = "docs/test.md",
-    en_mtime: datetime.datetime | None = None,
-    vi_mtime: datetime.datetime | None = None,
-    lag_days: int | None = None,
-    draft_marker: bool = False,
-    max_lag_days: int = 7,
-) -> FreshnessRow:
-    return FreshnessRow(
-        vi_path=Path(vi_path),
-        en_path=Path(en_path),
-        en_mtime=en_mtime,
-        vi_mtime=vi_mtime,
-        lag_days=lag_days,
-        draft_marker_present=draft_marker,
-        status="fresh",
-        max_lag_days=max_lag_days,
-    )
-
-
-class TestFileMtime:
-    def test_missing_file(self, tmp_path: Path) -> None:
-        assert _file_mtime(tmp_path / "nope.md") is None
-
-    def test_existing_file(self, tmp_path: Path) -> None:
-        p = tmp_path / "file.md"
-        p.write_text("hello")
-        mt = _file_mtime(p)
-        assert mt is not None
-        assert abs((datetime.datetime.now(datetime.UTC) - mt).total_seconds()) < 2
-
-
-class TestHasDraftMarker:
-    def test_present_in_first_20(self, tmp_path: Path) -> None:
-        p = tmp_path / "draft.md"
-        p.write_text("\n".join(["<!-- draft-translation: needs-human-review -->", "# Title"]))
-        assert _has_draft_marker(p) is True
-
-    def test_absent(self, tmp_path: Path) -> None:
-        p = tmp_path / "clean.md"
-        p.write_text("# Title\n")
-        assert _has_draft_marker(p) is False
-
-    def test_after_20_lines(self, tmp_path: Path) -> None:
-        p = tmp_path / "late.md"
-        p.write_text("\n".join(["# Title"] * 25 + ["<!-- draft-translation: needs-human-review -->"]))
-        assert _has_draft_marker(p) is False
-
-
-class TestClassify:
-    def test_orphan_vi(self) -> None:
-        row = _make_row(en_mtime=None)
-        assert classify(row, threshold=None, include_drafts=False) == "orphan_vi"
-
-    def test_draft_skips_stale(self) -> None:
-        row = _make_row(
-            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
-            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
-            lag_days=31,
-            draft_marker=True,
-            max_lag_days=7,
-        )
-        assert classify(row, threshold=None, include_drafts=False) == "draft"
-
-    def test_include_drafts_allows_stale(self) -> None:
-        row = _make_row(
-            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
-            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
-            lag_days=31,
-            draft_marker=True,
-            max_lag_days=7,
-        )
-        assert classify(row, threshold=None, include_drafts=True) == "stale"
-
-    def test_stale_breach(self) -> None:
-        row = _make_row(
-            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
-            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
-            lag_days=31,
-            draft_marker=False,
-            max_lag_days=7,
-        )
-        assert classify(row, threshold=None, include_drafts=False) == "stale"
-
-    def test_fresh_healthy(self) -> None:
-        row = _make_row(
-            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
-            vi_mtime=datetime.datetime(2025, 12, 29, tzinfo=datetime.UTC),
-            lag_days=3,
-            draft_marker=False,
-            max_lag_days=7,
-        )
-        assert classify(row, threshold=None, include_drafts=False) == "fresh"
-
-    def test_threshold_override(self) -> None:
-        row = _make_row(
-            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
-            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
-            lag_days=31,
-            draft_marker=False,
-            max_lag_days=7,
-        )
-        # threshold=60 would make lag_days <= threshold → fresh
-        assert classify(row, threshold=60, include_drafts=False) == "fresh"
-
-    def test_orphan_never_stale(self) -> None:
-        row = _make_row(en_mtime=None, lag_days=None, draft_marker=False, max_lag_days=7)
-        # Even with a low threshold, orphan_vi takes priority
-        assert classify(row, threshold=0, include_drafts=False) == "orphan_vi"

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_lint_cli.py

@@ -1,224 +0,0 @@
-"""Unit tests for lint cli compliance report (FR-24)."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-from typer.testing import CliRunner
-from vds_cli.cli import app
-
-runner = CliRunner()
-
-
-@pytest.fixture
-def mock_compliant_workspace(tmp_path: Path) -> Path:
-    """Create a minimal workspace tree that passes all compliance checks."""
-    # Root pyproject.toml with vds-cli only + tool configs
-    root = tmp_path
-    (root / "pyproject.toml").write_text(
-        "[project]\n"
-        'name = "vds-scripts-workspace"\n'
-        'version = "0.0.0"\n'
-        "\n"
-        "[project.scripts]\n"
-        'vds-cli = "vds_cli.cli:app"\n'
-        "\n"
-        "[tool.ruff]\n"
-        "line-length = 120\n"
-        "\n"
-        "[tool.mypy]\n"
-        'python_version = "3.14"\n'
-        "\n"
-        "[tool.pytest.ini_options]\n"
-        'addopts = "--cov-fail-under=80"\n',
-        encoding="utf-8",
-    )
-
-    # vds_cli/pyproject.toml (package-level)
-    vds_cli_root = root / "vds_cli"
-    vds_cli_root.mkdir(parents=True, exist_ok=True)
-    (vds_cli_root / "pyproject.toml").write_text(
-        "[project]\n"
-        'name = "vds-cli"\n'
-        'version = "0.0.0"\n'
-        "\n"
-        "[tool.pytest.ini_options]\n"
-        'addopts = "--cov-fail-under=80"\n',
-        encoding="utf-8",
-    )
-
-    # Create docs/agents/reference/cli-help-matrix.md with no drift
-    docs_dir = root / "docs" / "agents" / "reference"
-    docs_dir.mkdir(parents=True)
-    docs_dir.joinpath("cli-help-matrix.md").write_text(
-        "# Verified CLI help matrix\n\nUse `vds-cli` for all operations.\nDirect executables are internal.\n",
-        encoding="utf-8",
-    )
-
-    # vds_cli package stub
-    vds_cli_pkg = root / "vds_cli" / "src" / "vds_cli"
-    vds_cli_pkg.mkdir(parents=True)
-    (vds_cli_pkg / "__init__.py").write_text('__version__ = "4.0.0"\n', encoding="utf-8")
-    (vds_cli_pkg / "router.py").write_text(
-        "ORCHESTRATORS = {'jira': {}, 'confluence': {}}\n",
-        encoding="utf-8",
-    )
-    (vds_cli_pkg / "cli.py").write_text(
-        "import typer\napp = typer.Typer()\n",
-        encoding="utf-8",
-    )
-    # Add commands subpackage
-    cmd_dir = vds_cli_pkg / "commands"
-    cmd_dir.mkdir(parents=True, exist_ok=True)
-    (cmd_dir / "__init__.py").write_text("", encoding="utf-8")
-    (cmd_dir / "lint_cli.py").write_text("import typer\n", encoding="utf-8")
-
-    # vds_cli_common stub
-    vds_cli_common = root / "vds_cli_common" / "src" / "vds_cli_common"
-    vds_cli_common.mkdir(parents=True)
-    (vds_cli_common / "__init__.py").write_text("", encoding="utf-8")
-
-    # platform_core stub
-    plat = root / "platform_core" / "src" / "vds_platform_core"
-    plat.mkdir(parents=True)
-    (plat / "__init__.py").write_text("", encoding="utf-8")
-
-    return root
-
-
-def test_lint_cli_human_output(mock_compliant_workspace: Path) -> None:
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli"])
-    assert result.exit_code == 0
-    assert "Compliance Report" in result.stdout or "router_entry_count" in result.stdout
-    assert "PASS" in result.stdout or "Compliant" in result.stdout
-
-
-def test_lint_cli_json_output(mock_compliant_workspace: Path) -> None:
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    assert result.exit_code == 0
-    data = json.loads(result.stdout)
-    assert data["compliant"] is True
-    assert data["summary"]["failed"] == 0
-    assert any(f["check"] == "router_entry_count" for f in data["findings"])
-    assert any(f["check"] == "alias_count" for f in data["findings"])
-    assert any(f["check"] == "doc_drift" for f in data["findings"])
-
-
-def test_lint_cli_fails_on_legacy_alias(mock_compliant_workspace: Path) -> None:
-    """If a removed legacy alias is present, report should be non-compliant."""
-    pp = mock_compliant_workspace / "pyproject.toml"
-    text = pp.read_text(encoding="utf-8")
-    text = text.replace(
-        'vds-cli = "vds_cli.cli:app"',
-        'vds-cli = "vds_cli.cli:app"\nmdformat-vds = "vds_cli.cli:app"',
-    )
-    pp.write_text(text, encoding="utf-8")
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    assert result.exit_code == 1
-    data = json.loads(result.stdout)
-    assert data["compliant"] is False
-    alias_finding = next(f for f in data["findings"] if f["check"] == "alias_count")
-    assert alias_finding["ok"] is False
-    assert "mdformat-vds" in alias_finding["detail"]
-
-
-def test_lint_cli_fails_on_doc_drift(mock_compliant_workspace: Path) -> None:
-    md = mock_compliant_workspace / "docs" / "agents" / "reference" / "cli-help-matrix.md"
-    md.write_text(
-        "# Verified CLI help matrix\n\nRun `vds-audit` directly for speed.\n",
-        encoding="utf-8",
-    )
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    assert result.exit_code == 1
-    data = json.loads(result.stdout)
-    drift = next(f for f in data["findings"] if f["check"] == "doc_drift")
-    assert drift["ok"] is False
-    assert "vds-audit" in drift["detail"]
-
-
-def test_lint_cli_fails_on_missing_tool_config(mock_compliant_workspace: Path) -> None:
-    pp = mock_compliant_workspace / "pyproject.toml"
-    text = pp.read_text(encoding="utf-8")
-    # Remove tool.ruff and tool.mypy
-    lines = [ln for ln in text.splitlines() if not ln.startswith("[tool.ruff]") and not ln.startswith("[tool.mypy]")]
-    # Also strip ruff keys under it and mypy keys
-    filtered: list[str] = []
-    skip = False
-    for ln in lines:
-        if ln.startswith("[tool.ruff") or ln.startswith("[tool.mypy"):
-            skip = True
-            continue
-        if skip and ln.startswith("["):
-            skip = False
-        if skip:
-            continue
-        filtered.append(ln)
-    pp.write_text("\n".join(filtered) + "\n", encoding="utf-8")
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    assert result.exit_code == 1
-    data = json.loads(result.stdout)
-    ruff_finding = next(f for f in data["findings"] if f["check"] == "pyproject [ruff]")
-    mypy_finding = next(f for f in data["findings"] if f["check"] == "pyproject [mypy]")
-    assert ruff_finding["ok"] is False
-    assert mypy_finding["ok"] is False
-
-
-def test_lint_cli_fails_on_cli_patterns(mock_compliant_workspace: Path) -> None:
-    # Inject a cli.py with sys.exit(
-    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
-    cli.write_text("import sys\nsys.exit(1)\n", encoding="utf-8")
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    assert result.exit_code == 1
-    data = json.loads(result.stdout)
-    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
-    assert pat["ok"] is False
-    assert "sys.exit(" in pat["detail"]
-
-
-def test_lint_cli_detects_argparse(mock_compliant_workspace: Path) -> None:
-    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
-    cli.write_text("import argparse\n", encoding="utf-8")
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    data = json.loads(result.stdout)
-    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
-    assert pat["ok"] is False
-    assert "argparse" in pat["detail"]
-
-
-def test_lint_cli_detects_click(mock_compliant_workspace: Path) -> None:
-    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
-    cli.write_text("import click\n", encoding="utf-8")
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    data = json.loads(result.stdout)
-    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
-    assert pat["ok"] is False
-    assert "click" in pat["detail"]
-
-
-def test_lint_cli_detects_bare_runtimeerror(mock_compliant_workspace: Path) -> None:
-    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
-    cli.write_text("RuntimeError('oops')\n", encoding="utf-8")
-
-    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
-        result = runner.invoke(app, ["lint", "cli", "--json"])
-    data = json.loads(result.stdout)
-    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
-    assert pat["ok"] is False
-    assert "RuntimeError" in pat["detail"]