@mcptoolshop/accessibility-suite 0.1.0

package/src/a11y-lint/tests/test_cli.py

@@ -0,0 +1,200 @@
+"""Tests for CLI module."""
+
+import json
+import pytest
+import tempfile
+from pathlib import Path
+from click.testing import CliRunner
+
+from a11y_lint.cli import main
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    """Create a CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def sample_file(tmp_path: Path) -> Path:
+    """Create a sample file with some text."""
+    file = tmp_path / "sample.txt"
+    file.write_text("This is a test file.\nERROR: Something went wrong.\n")
+    return file
+
+
+@pytest.fixture
+def clean_file(tmp_path: Path) -> Path:
+    """Create a clean file with no issues."""
+    file = tmp_path / "clean.txt"
+    file.write_text("This is a clean file with no accessibility issues.\n")
+    return file
+
+
+@pytest.fixture
+def json_file(tmp_path: Path) -> Path:
+    """Create a valid JSON messages file."""
+    file = tmp_path / "messages.json"
+    data = [
+        {"level": "OK", "code": "TST001", "what": "Test passed"},
+        {"level": "WARN", "code": "TST002", "what": "Test warning", "why": "Reason"},
+    ]
+    file.write_text(json.dumps(data))
+    return file
+
+
+class TestMainCommand:
+    """Tests for main CLI group."""
+
+    def test_help(self, runner: CliRunner) -> None:
+        result = runner.invoke(main, ["--help"])
+        assert result.exit_code == 0
+        assert "Accessibility linter" in result.output
+
+    def test_version(self, runner: CliRunner) -> None:
+        result = runner.invoke(main, ["--version"])
+        assert result.exit_code == 0
+        assert "0.1.0" in result.output
+
+
+class TestScanCommand:
+    """Tests for scan command."""
+
+    def test_scan_file(self, runner: CliRunner, sample_file: Path) -> None:
+        result = runner.invoke(main, ["scan", str(sample_file)])
+        # Should find issues with "ERROR: Something went wrong"
+        assert "WARN" in result.output or "ERROR" in result.output
+
+    def test_scan_clean_file(self, runner: CliRunner, clean_file: Path) -> None:
+        result = runner.invoke(main, ["scan", str(clean_file)])
+        assert result.exit_code == 0
+
+    def test_scan_stdin(self, runner: CliRunner) -> None:
+        result = runner.invoke(main, ["scan", "--stdin"], input="Clean text.\n")
+        assert result.exit_code == 0
+
+    def test_scan_json_output(self, runner: CliRunner, sample_file: Path) -> None:
+        result = runner.invoke(main, ["scan", "--json", str(sample_file)])
+        data = json.loads(result.output)
+        assert "messages" in data
+        assert "summary" in data
+
+    def test_scan_markdown_output(self, runner: CliRunner, sample_file: Path) -> None:
+        result = runner.invoke(main, ["scan", "--format=markdown", str(sample_file)])
+        assert "# Accessibility Report" in result.output
+
+    def test_scan_no_input(self, runner: CliRunner) -> None:
+        result = runner.invoke(main, ["scan"])
+        assert result.exit_code == 1
+        assert "Must specify" in result.output
+
+    def test_scan_disable_rule(self, runner: CliRunner, tmp_path: Path) -> None:
+        file = tmp_path / "test.txt"
+        file.write_text("ERROR: It failed")
+        result = runner.invoke(
+            main,
+            ["scan", "--disable=no-ambiguous-pronouns", str(file)],
+        )
+        # Should not find ambiguous pronoun warning
+        assert "LNG004" not in result.output
+
+    def test_scan_strict_mode(self, runner: CliRunner, sample_file: Path) -> None:
+        # Strict mode treats warnings as errors
+        result = runner.invoke(main, ["scan", "--strict", str(sample_file)])
+        # If there are warnings, exit code should be 1
+        if "WARN" in result.output:
+            assert result.exit_code == 1
+
+
+class TestValidateCommand:
+    """Tests for validate command."""
+
+    def test_validate_valid_file(self, runner: CliRunner, json_file: Path) -> None:
+        result = runner.invoke(main, ["validate", str(json_file)])
+        assert result.exit_code == 0
+        assert "[OK]" in result.output
+
+    def test_validate_invalid_file(self, runner: CliRunner, tmp_path: Path) -> None:
+        file = tmp_path / "invalid.json"
+        file.write_text(json.dumps({"level": "INVALID", "code": "bad", "what": "x"}))
+        result = runner.invoke(main, ["validate", str(file)])
+        assert result.exit_code == 1
+        assert "[ERROR]" in result.output
+
+    def test_validate_verbose(self, runner: CliRunner, tmp_path: Path) -> None:
+        file = tmp_path / "invalid.json"
+        file.write_text(json.dumps({"level": "INVALID", "code": "bad", "what": "x"}))
+        result = runner.invoke(main, ["validate", "-v", str(file)])
+        assert result.exit_code == 1
+        # Verbose should show detailed errors
+        assert "level" in result.output.lower() or "code" in result.output.lower()
+
+
+class TestScorecardCommand:
+    """Tests for scorecard command."""
+
+    def test_scorecard_file(self, runner: CliRunner, sample_file: Path) -> None:
+        result = runner.invoke(main, ["scorecard", str(sample_file)])
+        assert "Scorecard" in result.output
+        assert "Score:" in result.output
+
+    def test_scorecard_json(self, runner: CliRunner, sample_file: Path) -> None:
+        result = runner.invoke(main, ["scorecard", "--json", str(sample_file)])
+        data = json.loads(result.output)
+        assert "overall_score" in data
+        assert "rules" in data
+
+    def test_scorecard_badge(self, runner: CliRunner, clean_file: Path) -> None:
+        result = runner.invoke(main, ["scorecard", "--badge", str(clean_file)])
+        assert "shields.io" in result.output
+
+    def test_scorecard_custom_name(self, runner: CliRunner, clean_file: Path) -> None:
+        result = runner.invoke(
+            main, ["scorecard", "--name=Custom Name", str(clean_file)]
+        )
+        assert "Custom Name" in result.output
+
+
+class TestReportCommand:
+    """Tests for report command."""
+
+    def test_report_stdout(self, runner: CliRunner, sample_file: Path) -> None:
+        result = runner.invoke(main, ["report", str(sample_file)])
+        assert "# Accessibility Report" in result.output
+
+    def test_report_to_file(
+        self, runner: CliRunner, sample_file: Path, tmp_path: Path
+    ) -> None:
+        output = tmp_path / "report.md"
+        result = runner.invoke(main, ["report", str(sample_file), "-o", str(output)])
+        assert result.exit_code == 0 or result.exit_code == 1  # Depends on errors
+        assert output.exists()
+        assert "# Accessibility Report" in output.read_text(encoding="utf-8")
+
+    def test_report_custom_title(self, runner: CliRunner, clean_file: Path) -> None:
+        result = runner.invoke(
+            main, ["report", "--title=Custom Title", str(clean_file)]
+        )
+        assert "# Custom Title" in result.output
+
+
+class TestListRulesCommand:
+    """Tests for list-rules command."""
+
+    def test_list_rules(self, runner: CliRunner) -> None:
+        result = runner.invoke(main, ["list-rules"])
+        assert result.exit_code == 0
+        assert "line-length" in result.output
+        assert "no-all-caps" in result.output
+        assert "plain-language" in result.output
+
+
+class TestSchemaCommand:
+    """Tests for schema command."""
+
+    def test_schema(self, runner: CliRunner) -> None:
+        result = runner.invoke(main, ["schema"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["title"] == "CLI Ground Truth Message"
+        assert "properties" in data

package/src/a11y-lint/tests/test_errors.py

@@ -0,0 +1,188 @@
+"""Tests for errors module."""
+
+import pytest
+
+from a11y_lint.errors import A11yMessage, Level, Location, ErrorCodes, CODE_PATTERN
+
+
+class TestLevel:
+    """Tests for Level enum."""
+
+    def test_level_values(self) -> None:
+        assert Level.OK.value == "OK"
+        assert Level.WARN.value == "WARN"
+        assert Level.ERROR.value == "ERROR"
+
+    def test_level_str(self) -> None:
+        assert str(Level.OK) == "OK"
+        assert str(Level.WARN) == "WARN"
+        assert str(Level.ERROR) == "ERROR"
+
+
+class TestLocation:
+    """Tests for Location dataclass."""
+
+    def test_empty_location(self) -> None:
+        loc = Location()
+        assert str(loc) == "<unknown>"
+        assert loc.to_dict() == {}
+
+    def test_full_location(self) -> None:
+        loc = Location(file="test.py", line=10, column=5, context="some text")
+        assert "test.py" in str(loc)
+        assert "line 10" in str(loc)
+        assert "col 5" in str(loc)
+
+        d = loc.to_dict()
+        assert d["file"] == "test.py"
+        assert d["line"] == 10
+        assert d["column"] == 5
+        assert d["context"] == "some text"
+
+    def test_location_truncates_context(self) -> None:
+        long_context = "x" * 300
+        loc = Location(context=long_context)
+        d = loc.to_dict()
+        assert len(d["context"]) == 200
+
+
+class TestCodePattern:
+    """Tests for error code pattern validation."""
+
+    def test_valid_codes(self) -> None:
+        assert CODE_PATTERN.match("A11Y001")
+        assert CODE_PATTERN.match("FMT123")
+        assert CODE_PATTERN.match("CLR999")
+        assert CODE_PATTERN.match("ABCD000")
+
+    def test_invalid_codes(self) -> None:
+        assert not CODE_PATTERN.match("A1")  # Too short
+        assert not CODE_PATTERN.match("a11y001")  # Lowercase
+        assert not CODE_PATTERN.match("A11Y01")  # Only 2 digits
+        assert not CODE_PATTERN.match("A11Y0001")  # 4 digits
+        assert not CODE_PATTERN.match("ABCDE001")  # 5 letters
+
+
+class TestA11yMessage:
+    """Tests for A11yMessage dataclass."""
+
+    def test_ok_message(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test passed")
+        assert msg.level == Level.OK
+        assert msg.code == "TST001"
+        assert msg.what == "Test passed"
+        assert msg.why is None
+        assert msg.fix is None
+
+    def test_warn_message(self) -> None:
+        msg = A11yMessage.warn(
+            "TST002",
+            "Test warning",
+            "This is a warning reason",
+            fix="Consider fixing this",
+        )
+        assert msg.level == Level.WARN
+        assert msg.code == "TST002"
+        assert msg.what == "Test warning"
+        assert msg.why == "This is a warning reason"
+        assert msg.fix == "Consider fixing this"
+
+    def test_error_message(self) -> None:
+        msg = A11yMessage.error(
+            "TST003",
+            "Test error",
+            "This is an error reason",
+            "Fix it like this",
+        )
+        assert msg.level == Level.ERROR
+        assert msg.code == "TST003"
+        assert msg.what == "Test error"
+        assert msg.why == "This is an error reason"
+        assert msg.fix == "Fix it like this"
+
+    def test_error_requires_why(self) -> None:
+        with pytest.raises(ValueError, match="must include 'why'"):
+            A11yMessage(
+                level=Level.ERROR,
+                code="TST001",
+                what="Test",
+                fix="Some fix",
+            )
+
+    def test_error_requires_fix(self) -> None:
+        with pytest.raises(ValueError, match="must include 'fix'"):
+            A11yMessage(
+                level=Level.ERROR,
+                code="TST001",
+                what="Test",
+                why="Some reason",
+            )
+
+    def test_invalid_code_raises(self) -> None:
+        with pytest.raises(ValueError, match="Invalid error code"):
+            A11yMessage.ok("invalid", "Test")
+
+    def test_empty_what_raises(self) -> None:
+        with pytest.raises(ValueError, match="cannot be empty"):
+            A11yMessage.ok("TST001", "")
+
+    def test_whitespace_what_raises(self) -> None:
+        with pytest.raises(ValueError, match="cannot be empty"):
+            A11yMessage.ok("TST001", "   ")
+
+    def test_to_dict(self) -> None:
+        msg = A11yMessage.error(
+            "TST001",
+            "Test error",
+            "Why",
+            "Fix",
+            rule="test-rule",
+            location=Location(file="test.py", line=1),
+            metadata={"key": "value"},
+        )
+        d = msg.to_dict()
+        assert d["level"] == "ERROR"
+        assert d["code"] == "TST001"
+        assert d["what"] == "Test error"
+        assert d["why"] == "Why"
+        assert d["fix"] == "Fix"
+        assert d["rule"] == "test-rule"
+        assert d["location"]["file"] == "test.py"
+        assert d["metadata"]["key"] == "value"
+
+    def test_from_dict(self) -> None:
+        data = {
+            "level": "WARN",
+            "code": "TST002",
+            "what": "Test warning",
+            "why": "Reason",
+            "location": {"file": "test.py", "line": 5},
+        }
+        msg = A11yMessage.from_dict(data)
+        assert msg.level == Level.WARN
+        assert msg.code == "TST002"
+        assert msg.what == "Test warning"
+        assert msg.why == "Reason"
+        assert msg.location is not None
+        assert msg.location.file == "test.py"
+        assert msg.location.line == 5
+
+    def test_truncates_long_what(self) -> None:
+        long_what = "x" * 300
+        msg = A11yMessage.ok("TST001", long_what)
+        assert len(msg.what) == 200
+
+    def test_truncates_long_why(self) -> None:
+        long_why = "y" * 600
+        msg = A11yMessage.warn("TST001", "Test", long_why)
+        assert len(msg.why) == 500
+
+
+class TestErrorCodes:
+    """Tests for ErrorCodes constants."""
+
+    def test_all_codes_valid(self) -> None:
+        for attr in dir(ErrorCodes):
+            if not attr.startswith("_"):
+                code = getattr(ErrorCodes, attr)
+                assert CODE_PATTERN.match(code), f"{attr} = {code} is invalid"

package/src/a11y-lint/tests/test_render.py

@@ -0,0 +1,202 @@
+"""Tests for render module."""
+
+import io
+import pytest
+
+from a11y_lint.render import (
+    render,
+    render_plain,
+    render_colored,
+    render_batch,
+    Renderer,
+    format_for_file,
+    Colors,
+    get_level_color,
+)
+from a11y_lint.errors import A11yMessage, Level, Location
+
+
+class TestRenderPlain:
+    """Tests for render_plain function."""
+
+    def test_ok_message(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test passed")
+        output = render_plain(msg)
+        assert "[OK] TST001: Test passed" in output
+
+    def test_warn_message(self) -> None:
+        msg = A11yMessage.warn("TST002", "Test warning", "This is why")
+        output = render_plain(msg)
+        assert "[WARN] TST002: Test warning" in output
+        assert "Why: This is why" in output
+
+    def test_error_message(self) -> None:
+        msg = A11yMessage.error("TST003", "Test error", "Reason", "Fix this")
+        output = render_plain(msg)
+        assert "[ERROR] TST003: Test error" in output
+        assert "Why: Reason" in output
+        assert "Fix: Fix this" in output
+
+    def test_message_with_location(self) -> None:
+        msg = A11yMessage.ok(
+            "TST001",
+            "Test",
+            location=Location(file="test.py", line=10, column=5),
+        )
+        output = render_plain(msg)
+        assert "at test.py" in output
+        assert "line 10" in output
+        assert "col 5" in output
+
+    def test_indentation(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test")
+        output = render_plain(msg, indent=4)
+        assert output.startswith("    [OK]")
+
+
+class TestRenderColored:
+    """Tests for render_colored function."""
+
+    def test_contains_color_codes(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test")
+        output = render_colored(msg)
+        assert Colors.OK in output
+        assert Colors.RESET in output
+
+    def test_error_uses_red(self) -> None:
+        msg = A11yMessage.error("TST001", "Test", "Why", "Fix")
+        output = render_colored(msg)
+        assert Colors.ERROR in output
+
+    def test_warn_uses_yellow(self) -> None:
+        msg = A11yMessage.warn("TST001", "Test", "Why")
+        output = render_colored(msg)
+        assert Colors.WARN in output
+
+
+class TestRender:
+    """Tests for render function."""
+
+    def test_default_no_color(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test")
+        output = render(msg)
+        assert Colors.OK not in output
+
+    def test_color_enabled(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test")
+        output = render(msg, color=True)
+        assert Colors.OK in output
+
+    def test_color_disabled(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test")
+        output = render(msg, color=False)
+        assert Colors.OK not in output
+
+
+class TestRenderBatch:
+    """Tests for render_batch function."""
+
+    def test_multiple_messages(self) -> None:
+        messages = [
+            A11yMessage.ok("TST001", "Test 1"),
+            A11yMessage.ok("TST002", "Test 2"),
+        ]
+        output = render_batch(messages)
+        assert "TST001" in output
+        assert "TST002" in output
+
+    def test_custom_separator(self) -> None:
+        messages = [
+            A11yMessage.ok("TST001", "Test 1"),
+            A11yMessage.ok("TST002", "Test 2"),
+        ]
+        output = render_batch(messages, separator="\n\n")
+        assert "\n\n" in output
+
+
+class TestGetLevelColor:
+    """Tests for get_level_color function."""
+
+    def test_ok_green(self) -> None:
+        assert get_level_color(Level.OK) == Colors.OK
+
+    def test_warn_yellow(self) -> None:
+        assert get_level_color(Level.WARN) == Colors.WARN
+
+    def test_error_red(self) -> None:
+        assert get_level_color(Level.ERROR) == Colors.ERROR
+
+
+class TestRenderer:
+    """Tests for Renderer class."""
+
+    def test_render_to_stream(self) -> None:
+        stream = io.StringIO()
+        renderer = Renderer(color=False, stream=stream)
+        msg = A11yMessage.ok("TST001", "Test")
+        renderer.write(msg)
+        output = stream.getvalue()
+        assert "[OK] TST001: Test" in output
+
+    def test_counts_messages(self) -> None:
+        stream = io.StringIO()
+        renderer = Renderer(color=False, stream=stream)
+
+        renderer.write(A11yMessage.ok("TST001", "Test 1"))
+        renderer.write(A11yMessage.warn("TST002", "Test 2", "Why"))
+        renderer.write(A11yMessage.error("TST003", "Test 3", "Why", "Fix"))
+
+        assert renderer.ok_count == 1
+        assert renderer.warn_count == 1
+        assert renderer.error_count == 1
+        assert renderer.total_count == 3
+
+    def test_summary_line(self) -> None:
+        renderer = Renderer(color=False, stream=io.StringIO())
+        assert renderer.summary_line() == "No issues found"
+
+        renderer.write(A11yMessage.ok("TST001", "Test"))
+        assert "1 passed" in renderer.summary_line()
+
+        renderer.write(A11yMessage.warn("TST002", "Test", "Why"))
+        assert "1 warnings" in renderer.summary_line()
+
+        renderer.write(A11yMessage.error("TST003", "Test", "Why", "Fix"))
+        assert "1 errors" in renderer.summary_line()
+
+    def test_write_batch(self) -> None:
+        stream = io.StringIO()
+        renderer = Renderer(color=False, stream=stream)
+        messages = [
+            A11yMessage.ok("TST001", "Test 1"),
+            A11yMessage.ok("TST002", "Test 2"),
+        ]
+        renderer.write_batch(messages)
+        output = stream.getvalue()
+        assert "TST001" in output
+        assert "TST002" in output
+        assert renderer.total_count == 2
+
+    def test_auto_detect_color(self) -> None:
+        # StringIO doesn't have isatty, so should default to no color
+        stream = io.StringIO()
+        renderer = Renderer(stream=stream)
+        assert renderer.color is False
+
+
+class TestFormatForFile:
+    """Tests for format_for_file function."""
+
+    def test_no_colors(self) -> None:
+        messages = [A11yMessage.ok("TST001", "Test")]
+        output = format_for_file(messages)
+        assert Colors.OK not in output
+
+    def test_blank_lines_between(self) -> None:
+        messages = [
+            A11yMessage.ok("TST001", "Test 1"),
+            A11yMessage.ok("TST002", "Test 2"),
+        ]
+        output = format_for_file(messages)
+        # Should have blank line between messages
+        assert "\n\n" in output