@mcptoolshop/accessibility-suite 0.1.0

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

@@ -0,0 +1,188 @@
+"""Tests for report_md module."""
+
+import pytest
+from io import StringIO
+
+from a11y_lint.report_md import (
+    render_message_md,
+    render_scorecard_md,
+    render_report_md,
+    MarkdownReporter,
+    generate_badge_md,
+)
+from a11y_lint.errors import A11yMessage, Level, Location
+from a11y_lint.scorecard import Scorecard
+
+
+class TestRenderMessageMd:
+    """Tests for render_message_md function."""
+
+    def test_ok_message(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test passed")
+        md = render_message_md(msg)
+        assert "### " in md
+        assert "[OK]" in md
+        assert "TST001" in md
+        assert "Test passed" in md
+
+    def test_error_message_has_why_fix(self) -> None:
+        msg = A11yMessage.error("TST001", "Error", "This is why", "This is fix")
+        md = render_message_md(msg)
+        assert "**Why:**" in md
+        assert "This is why" in md
+        assert "**Fix:**" in md
+        assert "This is fix" in md
+
+    def test_message_with_location(self) -> None:
+        msg = A11yMessage.ok(
+            "TST001",
+            "Test",
+            location=Location(file="test.py", line=10, column=5),
+        )
+        md = render_message_md(msg)
+        assert "**Location:**" in md
+        assert "test.py" in md
+        assert "line 10" in md
+
+    def test_message_with_context(self) -> None:
+        msg = A11yMessage.ok(
+            "TST001",
+            "Test",
+            location=Location(context="some code here"),
+        )
+        md = render_message_md(msg)
+        assert "```" in md
+        assert "some code here" in md
+
+    def test_message_with_rule(self) -> None:
+        msg = A11yMessage.ok("TST001", "Test", rule="test-rule")
+        md = render_message_md(msg)
+        assert "*Rule: `test-rule`*" in md
+
+
+class TestRenderScorecardMd:
+    """Tests for render_scorecard_md function."""
+
+    def test_empty_scorecard(self) -> None:
+        card = Scorecard(name="Test Card")
+        md = render_scorecard_md(card)
+        assert "# Test Card" in md
+        assert "100.0% (A)" in md
+
+    def test_scorecard_with_rules(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_message(A11yMessage.ok("TST001", "Test", rule="rule-a"))
+        card.add_message(A11yMessage.warn("TST002", "Test", "Why", rule="rule-b"))
+        md = render_scorecard_md(card)
+        assert "## Rules" in md
+        assert "`rule-a`" in md
+        assert "`rule-b`" in md
+
+    def test_scorecard_summary_table(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_message(A11yMessage.ok("TST001", "Test", rule="r"))
+        md = render_scorecard_md(card)
+        assert "| Metric | Count |" in md
+        assert "| Total Checks | 1 |" in md
+
+
+class TestRenderReportMd:
+    """Tests for render_report_md function."""
+
+    def test_empty_report(self) -> None:
+        md = render_report_md([])
+        assert "# Accessibility Report" in md
+        assert "## Summary" in md
+        assert "Passing" in md
+
+    def test_report_with_errors(self) -> None:
+        messages = [
+            A11yMessage.error("TST001", "Error 1", "Why", "Fix", rule="r"),
+        ]
+        md = render_report_md(messages)
+        assert "Failing" in md
+        assert "## Errors" in md
+        assert "Errors: 1" in md
+
+    def test_report_with_warnings(self) -> None:
+        messages = [
+            A11yMessage.warn("TST001", "Warning 1", "Why", rule="r"),
+        ]
+        md = render_report_md(messages)
+        assert "## Warnings" in md
+        assert "Warnings: 1" in md
+
+    def test_report_with_passed(self) -> None:
+        messages = [
+            A11yMessage.ok("TST001", "Passed 1", rule="r"),
+        ]
+        md = render_report_md(messages)
+        assert "## Passed" in md
+        assert "TST001" in md
+
+    def test_custom_title(self) -> None:
+        md = render_report_md([], title="Custom Title")
+        assert "# Custom Title" in md
+
+    def test_timestamp(self) -> None:
+        md = render_report_md([], include_timestamp=True)
+        assert "*Generated:" in md
+
+    def test_no_timestamp(self) -> None:
+        md = render_report_md([], include_timestamp=False)
+        assert "*Generated:" not in md
+
+
+class TestMarkdownReporter:
+    """Tests for MarkdownReporter class."""
+
+    def test_render(self) -> None:
+        reporter = MarkdownReporter(title="Test Report")
+        messages = [A11yMessage.ok("TST001", "Test")]
+        md = reporter.render(messages)
+        assert "# Test Report" in md
+
+    def test_render_scorecard(self) -> None:
+        reporter = MarkdownReporter()
+        card = Scorecard(name="Test Card")
+        md = reporter.render_scorecard(card)
+        assert "# Test Card" in md
+
+    def test_write_to_stream(self) -> None:
+        reporter = MarkdownReporter()
+        messages = [A11yMessage.ok("TST001", "Test")]
+        stream = StringIO()
+        reporter.write(messages, stream)
+        output = stream.getvalue()
+        assert "# Accessibility Report" in output
+
+
+class TestGenerateBadgeMd:
+    """Tests for generate_badge_md function."""
+
+    def test_high_score_green(self) -> None:
+        badge = generate_badge_md(95)
+        assert "brightgreen" in badge
+        assert "95%25" in badge
+
+    def test_medium_score_yellow(self) -> None:
+        badge = generate_badge_md(75)
+        assert "yellow" in badge
+
+    def test_low_score_orange(self) -> None:
+        badge = generate_badge_md(55)
+        assert "orange" in badge
+
+    def test_very_low_score_red(self) -> None:
+        badge = generate_badge_md(40)
+        assert "red" in badge
+
+    def test_custom_label(self) -> None:
+        badge = generate_badge_md(90, label="accessibility")
+        assert "accessibility" in badge
+
+    def test_shields_io_format(self) -> None:
+        badge = generate_badge_md(90)
+        assert "shields.io/badge" in badge
+        assert "![" in badge
+        assert "](" in badge

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

@@ -0,0 +1,290 @@
+"""Tests for scan_cli_text module."""
+
+import pytest
+
+from a11y_lint.scan_cli_text import (
+    Scanner,
+    scan,
+    get_rule_names,
+    RULES,
+    check_line_length,
+    check_all_caps,
+    check_jargon,
+    check_color_only,
+    check_emoji_overuse,
+    check_missing_punctuation,
+    check_error_structure,
+    check_ambiguous_pronouns,
+    MAX_LINE_LENGTH,
+)
+from a11y_lint.errors import Level, ErrorCodes
+
+
+class TestCheckLineLength:
+    """Tests for line length check."""
+
+    def test_short_line_ok(self) -> None:
+        result = check_line_length("Short line", None, 1)
+        assert result is None
+
+    def test_long_line_warns(self) -> None:
+        long_line = "x" * (MAX_LINE_LENGTH + 1)
+        result = check_line_length(long_line, None, 1)
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.LINE_TOO_LONG
+
+    def test_exactly_max_length_ok(self) -> None:
+        line = "x" * MAX_LINE_LENGTH
+        result = check_line_length(line, None, 1)
+        assert result is None
+
+
+class TestCheckAllCaps:
+    """Tests for all caps check."""
+
+    def test_normal_text_ok(self) -> None:
+        result = check_all_caps("This is normal text", None, 1)
+        assert result is None
+
+    def test_all_caps_warns(self) -> None:
+        result = check_all_caps("THIS IS SHOUTING TEXT", None, 1)
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.ALL_CAPS_MESSAGE
+
+    def test_allowed_acronyms_ok(self) -> None:
+        result = check_all_caps("ERROR: Something went wrong", None, 1)
+        assert result is None
+
+    def test_short_caps_ok(self) -> None:
+        # Words with 4 or fewer caps are allowed
+        result = check_all_caps("The HTML page", None, 1)
+        assert result is None
+
+
+class TestCheckJargon:
+    """Tests for jargon check."""
+
+    def test_plain_text_ok(self) -> None:
+        result = check_jargon("File not found", None, 1)
+        assert result is None
+
+    def test_jargon_warns(self) -> None:
+        result = check_jargon("Received EOF unexpectedly", None, 1)
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.JARGON_DETECTED
+
+    def test_stdin_jargon(self) -> None:
+        result = check_jargon("Reading from STDIN", None, 1)
+        assert result is not None
+        assert "STDIN" in result.what
+
+    def test_pid_jargon(self) -> None:
+        result = check_jargon("Process PID: 12345", None, 1)
+        assert result is not None
+        assert "PID" in result.what
+
+
+class TestCheckColorOnly:
+    """Tests for color-only information check."""
+
+    def test_normal_text_ok(self) -> None:
+        result = check_color_only("Error: File not found", None, 1)
+        assert result is None
+
+    def test_color_only_errors(self) -> None:
+        result = check_color_only("Errors are shown in red", None, 1)
+        assert result is not None
+        assert result.level == Level.ERROR
+        assert result.code == ErrorCodes.COLOR_ONLY_INFO
+
+    def test_color_indicates_errors(self) -> None:
+        result = check_color_only("Green indicates success", None, 1)
+        assert result is not None
+        assert result.level == Level.ERROR
+
+    def test_highlighted_in_color(self) -> None:
+        result = check_color_only("Errors are highlighted in yellow", None, 1)
+        assert result is not None
+
+
+class TestCheckEmojiOveruse:
+    """Tests for emoji overuse check."""
+
+    def test_no_emoji_ok(self) -> None:
+        result = check_emoji_overuse("Normal text", None, 1)
+        assert result is None
+
+    def test_few_emoji_ok(self) -> None:
+        result = check_emoji_overuse("Hello \U0001F600\U0001F600\U0001F600", None, 1)
+        assert result is None  # 3 or fewer is OK
+
+    def test_many_emoji_warns(self) -> None:
+        result = check_emoji_overuse(
+            "Hello \U0001F600\U0001F600\U0001F600\U0001F600\U0001F600", None, 1
+        )
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.EMOJI_OVERUSE
+
+
+class TestCheckMissingPunctuation:
+    """Tests for missing punctuation check."""
+
+    def test_normal_text_not_checked(self) -> None:
+        # Only error-like messages are checked
+        result = check_missing_punctuation("Normal text without punctuation", None, 1)
+        assert result is None
+
+    def test_error_with_punctuation_ok(self) -> None:
+        result = check_missing_punctuation("ERROR: File not found.", None, 1)
+        assert result is None
+
+    def test_error_without_punctuation_warns(self) -> None:
+        result = check_missing_punctuation("ERROR: File not found", None, 1)
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.NO_PUNCTUATION
+
+    def test_colon_counts_as_punctuation(self) -> None:
+        result = check_missing_punctuation("ERROR:", None, 1)
+        assert result is None
+
+
+class TestCheckErrorStructure:
+    """Tests for error structure check."""
+
+    def test_normal_text_not_checked(self) -> None:
+        result = check_error_structure("Normal text", None, 1)
+        assert result is None
+
+    def test_error_with_explanation_ok(self) -> None:
+        result = check_error_structure(
+            "ERROR: Failed because the file was not found", None, 1
+        )
+        assert result is None
+
+    def test_error_with_fix_ok(self) -> None:
+        result = check_error_structure(
+            "ERROR: Failed. Try running as administrator.", None, 1
+        )
+        assert result is None
+
+    def test_error_without_context_warns(self) -> None:
+        result = check_error_structure("ERROR: Operation failed", None, 1)
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.MISSING_WHY
+
+
+class TestCheckAmbiguousPronouns:
+    """Tests for ambiguous pronoun check."""
+
+    def test_clear_text_ok(self) -> None:
+        result = check_ambiguous_pronouns("The file was not found", None, 1)
+        assert result is None
+
+    def test_it_failed_warns(self) -> None:
+        result = check_ambiguous_pronouns("It failed", None, 1)
+        assert result is not None
+        assert result.level == Level.WARN
+        assert result.code == ErrorCodes.AMBIGUOUS_PRONOUN
+
+    def test_this_is_invalid_warns(self) -> None:
+        result = check_ambiguous_pronouns("This is invalid", None, 1)
+        assert result is not None
+
+    def test_pronoun_mid_sentence_ok(self) -> None:
+        # Only check at start of line
+        result = check_ambiguous_pronouns("The process failed because it ran out of memory", None, 1)
+        assert result is None
+
+
+class TestScanner:
+    """Tests for Scanner class."""
+
+    def test_scan_empty_text(self) -> None:
+        scanner = Scanner()
+        messages = scanner.scan_text("")
+        assert messages == []
+
+    def test_scan_clean_text(self) -> None:
+        scanner = Scanner()
+        # Use text that doesn't start with pronouns and has proper structure
+        messages = scanner.scan_text("File processed successfully.\nAll checks passed.")
+        assert len(messages) == 0
+
+    def test_scan_problematic_text(self) -> None:
+        scanner = Scanner()
+        messages = scanner.scan_text("ERROR: It failed")
+        # Should find: ambiguous pronoun, no punctuation, no explanation
+        assert len(messages) >= 2
+
+    def test_scan_with_source_file(self) -> None:
+        scanner = Scanner()
+        messages = scanner.scan_text("ERROR: It failed", file="test.txt")
+        for msg in messages:
+            if msg.location:
+                assert msg.location.file == "test.txt"
+
+    def test_disable_rule(self) -> None:
+        scanner = Scanner()
+        scanner.disable_rule("no-ambiguous-pronouns")
+        messages = scanner.scan_text("It failed")
+        # Should not find ambiguous pronoun warning
+        assert not any(m.code == ErrorCodes.AMBIGUOUS_PRONOUN for m in messages)
+
+    def test_enable_only_rule(self) -> None:
+        scanner = Scanner()
+        scanner.rules = []
+        scanner.enable_rule("no-all-caps")
+        messages = scanner.scan_text("THIS IS SHOUTING")
+        assert len(messages) == 1
+        assert messages[0].code == ErrorCodes.ALL_CAPS_MESSAGE
+
+    def test_error_and_warn_counts(self) -> None:
+        scanner = Scanner()
+        # Color-only is an error, others are warnings
+        scanner.scan_text("Errors are shown in red. THIS IS SHOUTING.")
+        assert scanner.error_count >= 1
+        assert scanner.warn_count >= 1
+
+    def test_has_errors(self) -> None:
+        scanner = Scanner()
+        scanner.scan_text("Errors are shown in red")
+        assert scanner.has_errors is True
+
+        scanner2 = Scanner()
+        scanner2.scan_text("Normal text.")
+        assert scanner2.has_errors is False
+
+
+class TestScanFunction:
+    """Tests for scan convenience function."""
+
+    def test_scan_returns_messages(self) -> None:
+        messages = scan("ERROR: It failed")
+        assert len(messages) >= 1
+
+    def test_scan_with_file(self) -> None:
+        messages = scan("ERROR: It failed", file="test.py")
+        for msg in messages:
+            if msg.location and msg.location.file:
+                assert msg.location.file == "test.py"
+
+
+class TestGetRuleNames:
+    """Tests for get_rule_names function."""
+
+    def test_returns_all_rules(self) -> None:
+        names = get_rule_names()
+        assert len(names) == len(RULES)
+
+    def test_known_rules_present(self) -> None:
+        names = get_rule_names()
+        assert "line-length" in names
+        assert "no-all-caps" in names
+        assert "plain-language" in names
+        assert "no-color-only" in names

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

@@ -0,0 +1,195 @@
+"""Tests for scorecard module."""
+
+import pytest
+
+from a11y_lint.scorecard import (
+    RuleScore,
+    Scorecard,
+    ScorecardBuilder,
+    create_scorecard,
+)
+from a11y_lint.errors import A11yMessage, Level
+
+
+class TestRuleScore:
+    """Tests for RuleScore dataclass."""
+
+    def test_empty_score(self) -> None:
+        score = RuleScore(rule="test")
+        assert score.total == 0
+        assert score.score == 100.0  # No failures = perfect
+        assert score.grade == "A"
+
+    def test_all_passed(self) -> None:
+        score = RuleScore(rule="test", passed=10)
+        assert score.total == 10
+        assert score.score == 100.0
+        assert score.grade == "A"
+
+    def test_all_errors(self) -> None:
+        score = RuleScore(rule="test", errors=10)
+        assert score.total == 10
+        assert score.score == 0.0
+        assert score.grade == "F"
+
+    def test_all_warnings(self) -> None:
+        score = RuleScore(rule="test", warnings=10)
+        assert score.total == 10
+        assert score.score == 50.0  # Warnings = half points
+        assert score.grade == "F"
+
+    def test_mixed_results(self) -> None:
+        score = RuleScore(rule="test", passed=7, warnings=2, errors=1)
+        assert score.total == 10
+        # 7 + (2 * 0.5) + 0 = 8 / 10 = 80%
+        assert score.score == 80.0
+        assert score.grade == "B"
+
+    def test_grade_boundaries(self) -> None:
+        # A: >= 90
+        assert RuleScore(rule="t", passed=9, errors=1).grade == "A"
+        # B: >= 80
+        assert RuleScore(rule="t", passed=8, errors=2).grade == "B"
+        # C: >= 70
+        assert RuleScore(rule="t", passed=7, errors=3).grade == "C"
+        # D: >= 60
+        assert RuleScore(rule="t", passed=6, errors=4).grade == "D"
+        # F: < 60
+        assert RuleScore(rule="t", passed=5, errors=5).grade == "F"
+
+
+class TestScorecard:
+    """Tests for Scorecard class."""
+
+    def test_empty_scorecard(self) -> None:
+        card = Scorecard(name="Test")
+        assert card.total_checks == 0
+        assert card.overall_score == 100.0
+        assert card.is_passing is True
+
+    def test_add_ok_message(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_message(A11yMessage.ok("TST001", "Passed", rule="test-rule"))
+        assert card.total_passed == 1
+        assert card.total_warnings == 0
+        assert card.total_errors == 0
+        assert "test-rule" in card.rule_scores
+
+    def test_add_warn_message(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_message(A11yMessage.warn("TST001", "Warning", "Why", rule="test-rule"))
+        assert card.total_warnings == 1
+        assert card.is_passing is True  # Warnings don't fail
+
+    def test_add_error_message(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_message(
+            A11yMessage.error("TST001", "Error", "Why", "Fix", rule="test-rule")
+        )
+        assert card.total_errors == 1
+        assert card.is_passing is False
+
+    def test_add_messages_batch(self) -> None:
+        card = Scorecard(name="Test")
+        messages = [
+            A11yMessage.ok("TST001", "Test 1", rule="rule-a"),
+            A11yMessage.warn("TST002", "Test 2", "Why", rule="rule-b"),
+            A11yMessage.error("TST003", "Test 3", "Why", "Fix", rule="rule-a"),
+        ]
+        card.add_messages(messages)
+        assert card.total_checks == 3
+        assert len(card.rule_scores) == 2
+
+    def test_overall_score_calculation(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_messages(
+            [
+                A11yMessage.ok("TST001", "Test 1", rule="r"),
+                A11yMessage.ok("TST002", "Test 2", rule="r"),
+                A11yMessage.warn("TST003", "Test 3", "Why", rule="r"),
+                A11yMessage.error("TST004", "Test 4", "Why", "Fix", rule="r"),
+            ]
+        )
+        # 2 passed + 0.5 warn + 0 error = 2.5 / 4 = 62.5%
+        assert card.overall_score == 62.5
+        assert card.overall_grade == "D"
+
+    def test_summary(self) -> None:
+        card = Scorecard(name="Test Card")
+        card.add_message(A11yMessage.ok("TST001", "Test", rule="test"))
+        summary = card.summary()
+        assert "Test Card" in summary
+        assert "Passed: 1" in summary
+
+    def test_to_dict(self) -> None:
+        card = Scorecard(name="Test")
+        card.add_message(A11yMessage.ok("TST001", "Test", rule="test-rule"))
+        d = card.to_dict()
+        assert d["name"] == "Test"
+        assert d["overall_score"] == 100.0
+        assert d["overall_grade"] == "A"
+        assert d["is_passing"] is True
+        assert d["totals"]["passed"] == 1
+        assert "test-rule" in d["rules"]
+        assert len(d["messages"]) == 1
+
+    def test_unknown_rule(self) -> None:
+        card = Scorecard(name="Test")
+        # Message without rule gets assigned to "unknown"
+        card.add_message(A11yMessage.ok("TST001", "Test"))
+        assert "unknown" in card.rule_scores
+
+
+class TestScorecardBuilder:
+    """Tests for ScorecardBuilder class."""
+
+    def test_build_empty(self) -> None:
+        builder = ScorecardBuilder()
+        card = builder.build()
+        assert card.total_checks == 0
+
+    def test_custom_name(self) -> None:
+        builder = ScorecardBuilder(name="Custom Name")
+        card = builder.build()
+        assert card.name == "Custom Name"
+
+    def test_add_scan_result(self) -> None:
+        messages = [
+            A11yMessage.ok("TST001", "Test 1", rule="r"),
+            A11yMessage.ok("TST002", "Test 2", rule="r"),
+        ]
+        builder = ScorecardBuilder()
+        builder.add_scan_result(messages)
+        card = builder.build()
+        assert card.total_checks == 2
+
+    def test_add_ok_check(self) -> None:
+        builder = ScorecardBuilder()
+        builder.add_ok_check("test-rule", "TST001", "Test passed")
+        card = builder.build()
+        assert card.total_passed == 1
+
+    def test_chaining(self) -> None:
+        card = (
+            ScorecardBuilder(name="Chained")
+            .add_ok_check("rule-1", "TST001", "Test 1")
+            .add_ok_check("rule-2", "TST002", "Test 2")
+            .build()
+        )
+        assert card.total_checks == 2
+
+
+class TestCreateScorecard:
+    """Tests for create_scorecard convenience function."""
+
+    def test_create_from_messages(self) -> None:
+        messages = [
+            A11yMessage.ok("TST001", "Test", rule="r"),
+            A11yMessage.warn("TST002", "Test", "Why", rule="r"),
+        ]
+        card = create_scorecard(messages)
+        assert card.total_checks == 2
+
+    def test_custom_name(self) -> None:
+        card = create_scorecard([], name="Custom")
+        assert card.name == "Custom"