@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/hexagonal_orchestrator/tests/test_cli_integration.py

@@ -1,942 +0,0 @@
-#!/usr/bin/env python3
-"""
-Integration tests for the hexagonal architecture CLI.
-
-These tests use subprocess.run() with uv run to test the full CLI execution.
-Tests in this file will be slower (~14s for 19 tests) but verify end-to-end behavior.
-
-Verifies clean JSON output and proper handling of --json-only, --quiet, and --verbose flags.
-"""
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-# Mark all tests in this file as integration + slow (subprocess-backed).
-# Run fast tests only: pytest -m "not slow" hexagonal_orchestrator/tests/
-pytestmark = [pytest.mark.integration, pytest.mark.slow]
-
-
-def test_cli_json_only_outputs_clean_json():
-    """
-    Test that --json-only outputs only valid JSON to stdout.
-
-    Requirements verified:
-    - P3-101: Move "Analyzing repository:" message to stderr
-    - P3-102: Ensure only JSON goes to stdout when --json-only
-    - P3-103: Add test for clean JSON output
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Check that stdout contains only valid JSON
-    try:
-        parsed = json.loads(result.stdout)
-        assert "repository_path" in parsed or "violations" in parsed or "compliance_level" in parsed, (
-            "JSON output should contain expected fields"
-        )
-        print("✅ Stdout contains valid JSON")
-    except json.JSONDecodeError as e:
-        print(f"❌ Stdout is not valid JSON: {e}")
-        print(f"Stdout content: {result.stdout[:500]}")
-        raise
-
-    # Check that stderr contains progress messages (if any)
-    if result.stderr:
-        print(f"✅ Stderr contains progress messages: {result.stderr[:200]}")
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-    print("✅ CLI exited successfully")
-
-
-def test_cli_json_only_parseable_with_python_json_module():
-    """
-    Test that --json-only output can be parsed by Python's json module.
-
-    This verifies the exact use case from the spec:
-    uv run vds-hexagonal tests/fixtures/java-noncompliant --json-only | python3 -c "import json, sys; json.load(sys.stdin)"
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --json-only and capture output
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Verify that Python can parse the JSON from stdout
-    try:
-        data = json.loads(result.stdout)
-        assert isinstance(data, dict), "Output should be a JSON object"
-        assert len(data) > 0, "JSON should have keys"
-        print("✅ Python json.loads successfully parsed the output")
-        print(f"✅ Parsed JSON with {len(data)} keys")
-    except json.JSONDecodeError as e:
-        print(f"❌ Failed to parse JSON: {e}")
-        print(f"Stdout length: {len(result.stdout)}")
-        print(f"Stderr: {result.stderr[:200]}")
-        raise
-
-    # Verify CLI exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-
-    # Test that it can be piped (simulate the pipe scenario)
-    # Write stdout to a temporary file and read it back
-    import tempfile
-
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
-        f.write(result.stdout)
-        temp_file = f.name
-
-    try:
-        # Read and parse the file
-        with open(temp_file) as f:
-            data2 = json.load(f)
-        assert len(data2) == len(data), "Parsed data should match"
-        print("✅ JSON can be saved to file and reloaded")
-    finally:
-        Path(temp_file).unlink()
-
-
-def test_cli_without_json_only_outputs_markdown():
-    """Test that without --json-only, output is markdown format."""
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI without --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Check that stdout contains markdown-style output
-    assert "=" * 60 in result.stdout or "HEXAGONAL ARCHITECTURE" in result.stdout, (
-        "Output should contain markdown-style report"
-    )
-    print("✅ Stdout contains markdown-style output")
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-    print("✅ CLI exited successfully")
-
-
-def test_cli_error_handling():
-    """Test that errors go to stderr and don't break JSON output."""
-    # Try to analyze a non-existent path
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            "/nonexistent/path/12345",
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Should exit with error code
-    assert result.returncode != 0, "CLI should exit with non-zero for invalid path"
-
-    # Error message should be in stderr
-    assert "Error:" in result.stderr or "does not exist" in result.stderr, "Error message should be in stderr"
-    print("✅ Error message in stderr")
-
-    # Stdout should be empty or contain only valid JSON (even for errors)
-    if result.stdout.strip():
-        try:
-            json.loads(result.stdout)
-            print("✅ Stdout contains valid JSON even for errors")
-        except json.JSONDecodeError:
-            # It's okay if stdout is empty for errors
-            print("✅ Stdout is empty for error case")
-
-
-def test_cli_quiet_flag_suppresses_progress():
-    """
-    Test that --quiet flag suppresses all non-error output.
-
-    Requirements verified:
-    - P3-201: Add --quiet flag to suppress progress
-    - P3-203: Move all progress messages to stderr
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --quiet
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--quiet",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Stderr should be minimal (only errors, no progress)
-    # With --quiet, only ERROR level logs should appear
-    print(f"Stderr length with --quiet: {len(result.stderr)}")
-    print(f"Stderr content: {result.stderr[:200]}")
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-    print("✅ CLI with --quiet exited successfully")
-
-
-def test_cli_quiet_with_json_only():
-    """
-    Test that --quiet --json-only produces clean JSON with no progress.
-
-    This is the CI pipeline use case.
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --quiet --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--quiet",
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Stdout should be valid JSON
-    try:
-        parsed = json.loads(result.stdout)
-        assert "repository_path" in parsed or "violations" in parsed or "compliance_level" in parsed
-        print("✅ --quiet --json-only produces valid JSON")
-    except json.JSONDecodeError as e:
-        print(f"❌ Stdout is not valid JSON: {e}")
-        print(f"Stdout: {result.stdout[:500]}")
-        raise
-
-    # Stderr should be minimal (only errors)
-    print(f"✅ Stderr length with --quiet --json-only: {len(result.stderr)}")
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-    print("✅ CLI with --quiet --json-only exited successfully")
-
-
-def test_cli_verbose_flag_shows_detailed_progress():
-    """
-    Test that --verbose flag shows detailed file-by-file progress.
-
-    Requirements verified:
-    - P3-202: Add --verbose flag for detailed logging
-    - P3-203: Move all progress messages to stderr
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --verbose
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--verbose",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # With --verbose, stderr should contain detailed progress
-    # Look for INFO level messages
-    print(f"Stderr length with --verbose: {len(result.stderr)}")
-    print(f"Stderr content (first 500 chars): {result.stderr[:500]}")
-
-    # Check that verbose output contains detailed information
-    # (structlog INFO messages)
-    if result.stderr:
-        # Should contain INFO level logs
-        assert "info" in result.stderr.lower() or "analyzing" in result.stderr.lower(), (
-            "Verbose mode should show detailed progress"
-        )
-        print("✅ --verbose shows detailed progress in stderr")
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-    print("✅ CLI with --verbose exited successfully")
-
-
-def test_cli_quiet_and_verbose_mutually_exclusive():
-    """
-    Test that --quiet and --verbose are mutually exclusive.
-
-    Requirements verified:
-    - P3-201, P3-202: Flags should be mutually exclusive
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with both --quiet and --verbose
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--quiet",
-            "--verbose",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Should exit with error code
-    assert result.returncode != 0, "CLI should exit with non-zero when --quiet and --verbose are both used"
-
-    # Error message should be in stderr
-    assert "mutually exclusive" in result.stderr.lower() or "error" in result.stderr.lower(), (
-        "Error message should indicate flags are mutually exclusive"
-    )
-    print("✅ --quiet and --verbose are correctly rejected as mutually exclusive")
-
-
-def test_cli_verbose_with_json_only():
-    """
-    Test that --verbose --json-only shows progress in stderr but JSON in stdout.
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --verbose --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--verbose",
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Stdout should be valid JSON
-    try:
-        parsed = json.loads(result.stdout)
-        assert "repository_path" in parsed or "violations" in parsed or "compliance_level" in parsed
-        print("✅ --verbose --json-only produces valid JSON in stdout")
-    except json.JSONDecodeError as e:
-        print(f"❌ Stdout is not valid JSON: {e}")
-        print(f"Stdout: {result.stdout[:500]}")
-        raise
-
-    # Stderr should contain detailed progress
-    print(f"✅ Stderr contains verbose progress: {len(result.stderr)} chars")
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-    print("✅ CLI with --verbose --json-only exited successfully")
-
-
-if __name__ == "__main__":
-    print("Testing CLI - Clean JSON Output (P3-1) and Progress Logging (P3-2)\n")
-
-    try:
-        # P3-1 tests
-        print("=" * 60)
-        print("P3-1: Clean JSON Output Tests")
-        print("=" * 60)
-        test_cli_json_only_outputs_clean_json()
-        test_cli_json_only_parseable_with_python_json_module()
-        test_cli_without_json_only_outputs_markdown()
-        test_cli_error_handling()
-
-        # P3-2 tests
-        print("\n" + "=" * 60)
-        print("P3-2: Progress Logging Tests")
-        print("=" * 60)
-        test_cli_quiet_flag_suppresses_progress()
-        test_cli_quiet_with_json_only()
-        test_cli_verbose_flag_shows_detailed_progress()
-        test_cli_quiet_and_verbose_mutually_exclusive()
-        test_cli_verbose_with_json_only()
-
-        print("\n" + "=" * 60)
-        print("✅ All CLI tests passed!")
-        print("=" * 60)
-        sys.exit(0)
-    except Exception as e:
-        print(f"\n❌ Test failed: {e}")
-        import traceback
-
-        traceback.print_exc()
-        sys.exit(1)  # ============================================================================
-# P3-4: Exit Codes Tests
-# ============================================================================
-
-
-def test_exit_code_0_success():
-    """
-    Test that CLI exits with 0 on successful analysis (P3-401).
-
-    Exit code 0 indicates analysis completed successfully.
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Verify exit code 0
-    assert result.returncode == 0, f"Expected exit code 0, got {result.returncode}"
-    print("✅ CLI exits with 0 on success")
-
-
-def test_exit_code_1_nonexistent_path():
-    """
-    Test that CLI exits with 1 for non-existent repository path (P3-401).
-
-    Exit code 1 indicates a runtime error.
-    """
-    # Try to analyze a non-existent path
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            "/nonexistent/path/12345",
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Verify exit code 1 (runtime error)
-    assert result.returncode == 1, f"Expected exit code 1, got {result.returncode}"
-    print("✅ CLI exits with 1 for non-existent path")
-
-
-def test_exit_code_2_mutually_exclusive_flags():
-    """
-    Test that CLI exits with 2 for configuration error (P3-401).
-
-    Exit code 2 indicates a configuration error (invalid options).
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        pytest.skip(f"Missing integration fixture: {fixture_path}")
-
-    # Try to use both --quiet and --verbose (mutually exclusive)
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--quiet",
-            "--verbose",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Verify exit code 2 (config error)
-    assert result.returncode == 2, f"Expected exit code 2, got {result.returncode}"
-    print("✅ CLI exits with 2 for mutually exclusive flags")
-
-
-def test_exit_code_3_violations_found():
-    """
-    Test that CLI exits with 3 when --exit-on-violations is set and violations found (P3-401).
-
-    Exit code 3 indicates violations found (for CI use).
-    """
-    # Get the path to a non-compliant fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        print("⚠️ Skipping test - fixture not found")
-        return
-
-    # Run with --exit-on-violations flag
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--exit-on-violations",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Verify exit code 3 if violations found
-    # (If no violations, should be 0)
-    if "Total Violations:" in result.stdout and "Total Violations: 0" not in result.stdout:
-        assert result.returncode == 3, f"Expected exit code 3 (violations), got {result.returncode}"
-        print("✅ CLI exits with 3 when --exit-on-violations and violations found")
-    else:
-        # No violations found, should exit 0
-        assert result.returncode == 0, f"Expected exit code 0 (no violations), got {result.returncode}"
-        print("✅ CLI exits with 0 when no violations found")
-
-
-def test_exit_codes_documented_in_help():
-    """
-    Test that exit codes are documented in help text (P3-402).
-    """
-    # Run with --help
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            "--help",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Check that help text mentions exit codes
-    help_text = result.stdout.lower()
-    assert "exit code" in help_text or "exit codes" in help_text, "Help text should document exit codes"
-    print("✅ Exit codes documented in help text")
-
-
-# ============================================================================
-# P3-5: Performance Metrics Tests
-# ============================================================================
-
-
-def test_timing_fields_in_json_output():
-    """
-    Test that JSON output includes timing fields (P3-501, P3-502, P3-503).
-
-    Should include:
-    - analysis_duration_seconds
-    - files_per_second
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        pytest.skip(f"Missing integration fixture: {fixture_path}")
-
-    # Run the CLI with --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Parse JSON output
-    data = json.loads(result.stdout)
-
-    # Check for timing fields
-    assert "analysis_duration_seconds" in data, "JSON should include analysis_duration_seconds"
-    assert isinstance(data["analysis_duration_seconds"], (int, float)), "analysis_duration_seconds should be numeric"
-    assert data["analysis_duration_seconds"] >= 0, "analysis_duration_seconds should be non-negative"
-
-    assert "files_per_second" in data, "JSON should include files_per_second"
-    assert isinstance(data["files_per_second"], (int, float)), "files_per_second should be numeric"
-
-    print("✅ JSON includes timing fields:")
-    print(f"   - analysis_duration_seconds: {data['analysis_duration_seconds']:.3f}")
-    print(f"   - files_per_second: {data['files_per_second']:.1f}")
-
-
-def test_timing_flag_adds_detailed_metrics():
-    """
-    Test that --timing flag adds detailed timing metrics (P3-504).
-
-    Should include:
-    - profiling_duration
-    - classification_duration
-    - analysis_duration
-    - file_analysis_times
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        pytest.skip(f"Missing integration fixture: {fixture_path}")
-
-    # Run the CLI with --timing flag
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-            "--timing",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Parse JSON output
-    data = json.loads(result.stdout)
-
-    # Check for detailed timing section
-    assert "timing" in data, "JSON should include timing section when --timing is set"
-
-    timing_data = data["timing"]
-    assert "profiling_duration" in timing_data, "timing should include profiling_duration"
-    assert "classification_duration" in timing_data, "timing should include classification_duration"
-    assert "analysis_duration" in timing_data, "timing should include analysis_duration"
-    assert "file_analysis_times" in timing_data, "timing should include file_analysis_times"
-
-    print("✅ --timing flag adds detailed metrics:")
-    print(f"   - profiling_duration: {timing_data['profiling_duration']:.3f}s")
-    print(f"   - classification_duration: {timing_data['classification_duration']:.3f}s")
-    print(f"   - analysis_duration: {timing_data['analysis_duration']:.3f}s")
-    print(f"   - file_analysis_times: {len(timing_data['file_analysis_times'])} files")
-
-
-def test_timing_in_markdown_output():
-    """
-    Test that timing metrics appear in Markdown output (P3-503).
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "java-noncompliant"
-
-    if not fixture_path.exists():
-        pytest.skip(f"Missing integration fixture: {fixture_path}")
-
-    # Run the CLI without --json-only (markdown output)
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,
-    )
-
-    # Check that output includes performance metrics
-    assert "Duration:" in result.stdout or "Performance:" in result.stdout, (
-        "Markdown output should include performance metrics"
-    )
-
-    print("✅ Markdown output includes timing metrics")
-
-
-def test_cli_clear_cache_flag():
-    """
-    Test that --clear-cache flag clears the cache before analysis.
-
-    Requirements verified:
-    - Cache is cleared before analysis
-    - Fresh analysis is performed (cache misses)
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "python-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --clear-cache and --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-            "--clear-cache",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Parse JSON output
-    try:
-        parsed = json.loads(result.stdout)
-
-        # Verify cache was cleared (should have cache misses, not hits)
-        assert "cache_hits" in parsed, "JSON should contain cache_hits"
-        assert "cache_misses" in parsed, "JSON should contain cache_misses"
-        assert "cache_enabled" in parsed, "JSON should contain cache_enabled"
-
-        # After clearing cache, we should have misses (fresh analysis)
-        assert parsed["cache_hits"] == 0, f"After --clear-cache, cache_hits should be 0, got {parsed['cache_hits']}"
-        assert parsed["cache_misses"] > 0, (
-            f"After --clear-cache, cache_misses should be > 0, got {parsed['cache_misses']}"
-        )
-        assert parsed["cache_enabled"] is True, "Caching should be enabled with --clear-cache"
-
-        print(f"✅ --clear-cache flag works correctly: cache cleared, {parsed['cache_misses']} cache misses")
-
-    except json.JSONDecodeError as e:
-        print(f"❌ Failed to parse JSON: {e}")
-        print(f"Stdout: {result.stdout[:500]}")
-        raise
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-
-
-def test_cli_no_cache_flag():
-    """
-    Test that --no-cache flag disables caching during analysis.
-
-    Requirements verified:
-    - Caching is disabled during analysis
-    - No cache hits or misses (caching disabled)
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "python-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with --no-cache and --json-only
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-            "--no-cache",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Parse JSON output
-    try:
-        parsed = json.loads(result.stdout)
-
-        # Verify caching is disabled
-        assert "cache_hits" in parsed, "JSON should contain cache_hits"
-        assert "cache_misses" in parsed, "JSON should contain cache_misses"
-        assert "cache_enabled" in parsed, "JSON should contain cache_enabled"
-
-        # With --no-cache, caching should be disabled
-        assert parsed["cache_enabled"] is False, (
-            f"With --no-cache, cache_enabled should be False, got {parsed['cache_enabled']}"
-        )
-        assert parsed["cache_hits"] == 0, f"With --no-cache, cache_hits should be 0, got {parsed['cache_hits']}"
-        assert parsed["cache_misses"] == 0, f"With --no-cache, cache_misses should be 0, got {parsed['cache_misses']}"
-
-        print("✅ --no-cache flag works correctly: caching disabled")
-
-    except json.JSONDecodeError as e:
-        print(f"❌ Failed to parse JSON: {e}")
-        print(f"Stdout: {result.stdout[:500]}")
-        raise
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"
-
-
-def test_cli_clear_cache_and_no_cache_together():
-    """
-    Test that --clear-cache and --no-cache flags work together correctly.
-
-    Requirements verified:
-    - Cache is cleared before analysis (--clear-cache)
-    - Caching is disabled during analysis (--no-cache)
-    """
-    # Get the path to the test fixture
-    fixture_path = Path(__file__).parent / "fixtures" / "python-noncompliant"
-
-    if not fixture_path.exists():
-        # Fallback to a simpler test if fixture doesn't exist
-        fixture_path = Path(__file__).parent.parent.parent
-
-    # Run the CLI with both --clear-cache and --no-cache
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "--project",
-            "hexagonal_orchestrator",
-            "vds-hexagonal",
-            str(fixture_path),
-            "--json-only",
-            "--clear-cache",
-            "--no-cache",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=Path(__file__).parent.parent.parent,  # vds-scripts directory
-    )
-
-    # Parse JSON output
-    try:
-        parsed = json.loads(result.stdout)
-
-        # Verify caching is disabled (no-cache takes precedence for the analysis)
-        assert "cache_enabled" in parsed, "JSON should contain cache_enabled"
-        assert parsed["cache_enabled"] is False, (
-            f"With --no-cache, cache_enabled should be False, got {parsed['cache_enabled']}"
-        )
-
-        # Cache should be cleared but not used during analysis
-        assert parsed["cache_hits"] == 0, f"cache_hits should be 0, got {parsed['cache_hits']}"
-        assert parsed["cache_misses"] == 0, f"With --no-cache, cache_misses should be 0, got {parsed['cache_misses']}"
-
-        print("✅ --clear-cache and --no-cache work together correctly: cache cleared, caching disabled")
-
-    except json.JSONDecodeError as e:
-        print(f"❌ Failed to parse JSON: {e}")
-        print(f"Stdout: {result.stdout[:500]}")
-        raise
-
-    # Verify exit code
-    assert result.returncode == 0, f"CLI should exit with 0, got {result.returncode}"