test_rule_registry.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_linter/test_rule_registry.py
 
"""
Purpose
-------
FS-509 regression coverage for the lint rule registry and ``--explain`` flag.
 
Responsibilities
----------------
- Validate that every rule in ``_DEFAULT_RULES`` has a ``RuleInfo`` entry.
- Validate ``get_rule_info()`` and ``list_rules()`` API surface.
- Validate that ``--explain`` produces human-readable and JSON output.
- Validate that ``--explain`` for an unknown rule returns exit code 1.
 
Diagnostics
-----------
Domain: LINTER-TESTS
    Levels:
        L2 — test lifecycle
        L3 — assertion details
        L4 — deep tracing
 
Contracts
---------
- Tests are read-only introspection of the rule registry; no files
  are written.
"""
 
from __future__ import annotations
 
import json
 
import pytest
 
from oct.linter.rule_registry import (
    RULE_REGISTRY,
    RuleInfo,
    get_rule_info,
    list_rules,
)
from oct.linter.oct_lint import _DEFAULT_RULES, run_linter
 
 
# -------------------------------------------------------------------
# Registry completeness
# -------------------------------------------------------------------
 
class TestRegistryCompleteness:
 
    def test_every_default_rule_has_registry_entry(self):
        for rule_name in _DEFAULT_RULES:
            assert rule_name in RULE_REGISTRY, (
                f"Rule '{rule_name}' is in _DEFAULT_RULES but missing from RULE_REGISTRY"
            )
 
    def test_registry_has_no_extra_rules(self):
        for rule_name in RULE_REGISTRY:
            assert rule_name in _DEFAULT_RULES, (
                f"Rule '{rule_name}' is in RULE_REGISTRY but missing from _DEFAULT_RULES"
            )
 
    def test_list_rules_returns_all_entries(self):
        rules = list_rules()
        assert len(rules) == len(_DEFAULT_RULES)
 
    def test_list_rules_returns_rule_info_instances(self):
        for rule in list_rules():
            assert isinstance(rule, RuleInfo)
 
 
# -------------------------------------------------------------------
# Lookup API
# -------------------------------------------------------------------
 
class TestLookupAPI:
 
    def test_get_known_rule(self):
        info = get_rule_info("header")
        assert info is not None
        assert info.name == "header"
 
    def test_get_unknown_rule_returns_none(self):
        assert get_rule_info("nonexistent_rule") is None
 
    def test_get_rule_info_for_each_rule(self):
        for name in _DEFAULT_RULES:
            info = get_rule_info(name)
            assert info is not None
            assert info.name == name
 
 
# -------------------------------------------------------------------
# RuleInfo field validation
# -------------------------------------------------------------------
 
class TestRuleInfoFields:
 
    @pytest.mark.parametrize("rule_name", list(_DEFAULT_RULES.keys()))
    def test_all_string_fields_non_empty(self, rule_name: str):
        info = RULE_REGISTRY[rule_name]
        assert info.label, f"{rule_name}: label is empty"
        assert info.rationale, f"{rule_name}: rationale is empty"
        assert info.correct_pattern, f"{rule_name}: correct_pattern is empty"
        assert info.common_mistake, f"{rule_name}: common_mistake is empty"
        assert info.spec_reference, f"{rule_name}: spec_reference is empty"
 
    @pytest.mark.parametrize("rule_name", list(_DEFAULT_RULES.keys()))
    def test_profiles_non_empty(self, rule_name: str):
        info = RULE_REGISTRY[rule_name]
        assert len(info.profiles) >= 1, f"{rule_name}: profiles is empty"
 
    def test_header_is_fixable(self):
        info = get_rule_info("header")
        assert info is not None
        assert info.fixable is True
 
    def test_non_fixable_rules(self):
        for name in ("docstring", "dbg_usage", "tests_exist"):
            info = get_rule_info(name)
            assert info is not None
            assert info.fixable is False
 
 
# -------------------------------------------------------------------
# --explain integration (via run_linter)
# -------------------------------------------------------------------
 
class TestExplainFlag:
 
    def test_explain_known_rule_returns_zero(self, tmp_path, capsys):
        result = run_linter(tmp_path, ["--explain", "header"])
        assert result == 0
        captured = capsys.readouterr()
        assert "Rule: header" in captured.out
        assert "Rationale:" in captured.out
        assert "Correct pattern:" in captured.out
        assert "Common mistake:" in captured.out
 
    def test_explain_json_output(self, tmp_path, capsys):
        result = run_linter(tmp_path, ["--explain", "header", "--json"])
        assert result == 0
        captured = capsys.readouterr()
        data = json.loads(captured.out)
        assert data["name"] == "header"
        assert "rationale" in data
        assert "correct_pattern" in data
        assert "common_mistake" in data
        assert "spec_reference" in data
        assert "fixable" in data
        assert "profiles" in data
 
    def test_explain_unknown_rule_returns_one(self, tmp_path, capsys):
        result = run_linter(tmp_path, ["--explain", "nonexistent"])
        assert result == 1
        captured = capsys.readouterr()
        assert "unknown rule" in captured.err
 
    def test_explain_unknown_rule_lists_available(self, tmp_path, capsys):
        run_linter(tmp_path, ["--explain", "nonexistent"])
        captured = capsys.readouterr()
        assert "Available rules:" in captured.err
        assert "header" in captured.err