test_lint_baseline.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_linter/test_lint_baseline.py
 
"""
Purpose
-------
FS-508 regression coverage for the lint baseline (snapshot + diff).
 
Responsibilities
----------------
- Validate save_baseline creates a file and returns a count.
- Validate load_baseline reads back saved data.
- Validate diff_against_baseline detects new and resolved violations.
- Validate --baseline and --against-baseline flag behaviour via run_linter.
- Validate mutually exclusive flag error.
 
Diagnostics
-----------
Domain: LINTER-TESTS
    Levels:
        L2 — test lifecycle
        L3 — assertion details
        L4 — deep tracing
 
Contracts
---------
- All baseline files are written to ``tmp_path``; no real project
  baselines are touched.
"""
 
from __future__ import annotations
 
import json
import textwrap
from pathlib import Path
 
import pytest
 
from oct.linter.lint_baseline import (
    BaselineEntry,
    LintBaseline,
    diff_against_baseline,
    load_baseline,
    save_baseline,
)
 
 
# -------------------------------------------------------------------
# Helpers
# -------------------------------------------------------------------
 
def _make_results(violations: list[tuple[str, str, str]]) -> list[dict]:
    """Build mock lint results with specified violations."""
    by_path: dict[str, list[tuple[str, str]]] = {}
    for path, rule, msg in violations:
        by_path.setdefault(path, []).append((rule, msg))
 
    results = []
    for path, items in by_path.items():
        checks = {}
        all_rules = [
            "header", "docstring", "diagnostics_profile", "dbg_usage",
            "dbg_import", "func_pattern", "syntax_warnings", "type_hints",
            "no_hardcoded_secrets", "dbg_assert_safety", "tests_exist",
        ]
        for rule in all_rules:
            failing = [(r, m) for r, m in items if r == rule]
            if failing:
                checks[rule] = {"pass": False, "message": failing[0][1]}
            else:
                checks[rule] = {"pass": True, "message": "OK"}
        results.append({
            "header": checks["header"]["pass"],
            "docstring": checks["docstring"]["pass"],
            "diagnostics_profile": checks["diagnostics_profile"]["pass"],
            "dbg_usage": checks["dbg_usage"]["pass"],
            "dbg_import": checks["dbg_import"]["pass"],
            "func_pattern": checks["func_pattern"]["pass"],
            "syntax_warnings": checks["syntax_warnings"]["pass"],
            "type_hints": checks["type_hints"]["pass"],
            "no_hardcoded_secrets": checks["no_hardcoded_secrets"]["pass"],
            "dbg_assert_safety": checks["dbg_assert_safety"]["pass"],
            "tests_exist": checks["tests_exist"]["pass"],
            "compliant": all(c["pass"] for c in checks.values()),
            "fixed": False,
            "rel": path,
            "waivers": [],
            "json_detail": {
                "path": path,
                "checks": checks,
                "compliant": all(c["pass"] for c in checks.values()),
                "waivers": [],
            },
        })
    return results
 
 
# -------------------------------------------------------------------
# save_baseline
# -------------------------------------------------------------------
 
class TestSaveBaseline:
 
    def test_creates_file(self, tmp_path: Path):
        results = _make_results([("foo.py", "header", "bad shebang")])
        bp = tmp_path / "baseline.json"
        count = save_baseline(results, bp, "strict")
        assert bp.is_file()
        assert count == 1
 
    def test_returns_violation_count(self, tmp_path: Path):
        results = _make_results([
            ("a.py", "header", "bad"),
            ("a.py", "docstring", "missing"),
            ("b.py", "header", "wrong"),
        ])
        bp = tmp_path / "baseline.json"
        count = save_baseline(results, bp, "strict")
        assert count == 3
 
    def test_creates_parent_dirs(self, tmp_path: Path):
        bp = tmp_path / "deep" / "nested" / "baseline.json"
        save_baseline([], bp, "strict")
        assert bp.is_file()
 
    def test_zero_violations(self, tmp_path: Path):
        results = _make_results([])
        bp = tmp_path / "baseline.json"
        count = save_baseline(results, bp, "strict")
        assert count == 0
 
 
# -------------------------------------------------------------------
# load_baseline
# -------------------------------------------------------------------
 
class TestLoadBaseline:
 
    def test_load_saved(self, tmp_path: Path):
        results = _make_results([("foo.py", "header", "bad shebang")])
        bp = tmp_path / "baseline.json"
        save_baseline(results, bp, "strict")
        bl = load_baseline(bp)
        assert bl is not None
        assert len(bl.entries) == 1
        assert bl.entries[0].path == "foo.py"
        assert bl.entries[0].rule == "header"
        assert bl.profile == "strict"
 
    def test_nonexistent_returns_none(self, tmp_path: Path):
        assert load_baseline(tmp_path / "nope.json") is None
 
    def test_corrupt_returns_none(self, tmp_path: Path):
        bp = tmp_path / "baseline.json"
        bp.write_text("not json!", encoding="utf-8")
        assert load_baseline(bp) is None
 
    def test_wrong_schema_returns_none(self, tmp_path: Path):
        bp = tmp_path / "baseline.json"
        bp.write_text(json.dumps({"_schema_version": "99.0"}), encoding="utf-8")
        assert load_baseline(bp) is None
 
 
# -------------------------------------------------------------------
# diff_against_baseline
# -------------------------------------------------------------------
 
class TestDiffAgainstBaseline:
 
    def test_detects_new_violations(self):
        baseline = LintBaseline(
            entries=[BaselineEntry("a.py", "header", "old issue")],
            oct_version="0.22.0", timestamp="", profile="strict",
        )
        current = _make_results([
            ("a.py", "header", "old issue"),
            ("b.py", "docstring", "new problem"),
        ])
        new, resolved = diff_against_baseline(current, baseline)
        assert len(new) == 1
        assert new[0][0] == "b.py"
        assert new[0][1] == "docstring"
 
    def test_detects_resolved_violations(self):
        baseline = LintBaseline(
            entries=[
                BaselineEntry("a.py", "header", "bad"),
                BaselineEntry("a.py", "docstring", "missing"),
            ],
            oct_version="0.22.0", timestamp="", profile="strict",
        )
        current = _make_results([("a.py", "header", "bad")])
        new, resolved = diff_against_baseline(current, baseline)
        assert len(new) == 0
        assert len(resolved) == 1
        assert resolved[0][1] == "docstring"
 
    def test_unchanged_suppressed(self):
        baseline = LintBaseline(
            entries=[BaselineEntry("a.py", "header", "bad")],
            oct_version="0.22.0", timestamp="", profile="strict",
        )
        current = _make_results([("a.py", "header", "bad")])
        new, resolved = diff_against_baseline(current, baseline)
        assert len(new) == 0
        assert len(resolved) == 0
 
    def test_empty_baseline_everything_is_new(self):
        baseline = LintBaseline(
            entries=[], oct_version="0.22.0", timestamp="", profile="strict",
        )
        current = _make_results([("a.py", "header", "bad")])
        new, resolved = diff_against_baseline(current, baseline)
        assert len(new) == 1
        assert len(resolved) == 0
 
 
# -------------------------------------------------------------------
# Integration with run_linter flags
# -------------------------------------------------------------------
 
class TestBaselineFlags:
 
    def test_mutually_exclusive(self, tmp_path: Path, capsys):
        from oct.linter.oct_lint import run_linter
        result = run_linter(tmp_path, ["--baseline", "--against-baseline"])
        assert result == 1
        captured = capsys.readouterr()
        assert "mutually exclusive" in captured.err
 
    def test_against_baseline_without_file(self, tmp_path: Path, capsys):
        from oct.linter.oct_lint import run_linter
        result = run_linter(tmp_path, ["--against-baseline"])
        assert result == 1
        captured = capsys.readouterr()
        assert "no baseline found" in captured.err