Add comprehensive pytest test suite (693 tests)

6 test modules validating plugin structure, content, and consistency:
- test_plugin_manifest: plugin.json keys, semver, paths, skill/rule counts
- test_skills: frontmatter, required sections, content quality, internal links (28 skills)
- test_rules: frontmatter, globs, body content (9 rules)
- test_docs_consistency: version/count sync across README, CLAUDE.md, CONTRIBUTING, ROADMAP
- test_internal_links: all relative markdown links resolve to existing files
- test_roadmap: current version marker, table counts, completed section integrity

CI integration: pytest runs in validate.yml after existing shell checks.
Also adds Python cache entries to .gitignore.

Made-with: Cursor

Author: TMHSDigital

.github/workflows/validate.yml

@@ -103,3 +103,14 @@ jobs:
           rule_count=$(ls rules/*.mdc 2>/dev/null | wc -l)
           echo "Skills: $skill_count"
           echo "Rules: $rule_count"
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install test dependencies
+        run: pip install -r requirements-test.txt
+
+      - name: Run test suite
+        run: pytest tests/ -v --tb=short

.gitignore

@@ -26,3 +26,8 @@ ehthumbs.db
 dist/
 build/
 *.log
+
+# Python
+__pycache__/
+*.pyc
+.pytest_cache/

requirements-test.txt

@@ -0,0 +1,2 @@
+pytest>=8.0
+pyyaml>=6.0

tests/conftest.py

@@ -0,0 +1,112 @@
+"""Shared fixtures for Steam Cursor Plugin test suite."""
+
+import json
+import re
+from pathlib import Path
+
+import pytest
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+SKILLS_DIR = REPO_ROOT / "skills"
+RULES_DIR = REPO_ROOT / "rules"
+PLUGIN_JSON = REPO_ROOT / ".cursor-plugin" / "plugin.json"
+
+
+def parse_frontmatter(text: str) -> tuple[dict, str]:
+    """Split YAML frontmatter from body. Returns (frontmatter_dict, body_str)."""
+    if not text.startswith("---"):
+        return {}, text
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return {}, text
+    fm = yaml.safe_load(parts[1]) or {}
+    body = parts[2].strip()
+    return fm, body
+
+
+def get_markdown_sections(body: str) -> dict[str, str]:
+    """Extract H1/H2 sections from markdown body. Returns {heading: content}."""
+    sections: dict[str, str] = {}
+    current_heading = None
+    current_lines: list[str] = []
+
+    for line in body.splitlines():
+        m = re.match(r"^(#{1,2})\s+(.+)$", line)
+        if m:
+            if current_heading is not None:
+                sections[current_heading] = "\n".join(current_lines).strip()
+            current_heading = m.group(2).strip()
+            current_lines = []
+        else:
+            current_lines.append(line)
+
+    if current_heading is not None:
+        sections[current_heading] = "\n".join(current_lines).strip()
+
+    return sections
+
+
+# ── Fixtures ────────────────────────────────────────────────────────
+
+
+@pytest.fixture(scope="session")
+def repo_root():
+    return REPO_ROOT
+
+
+@pytest.fixture(scope="session")
+def plugin_manifest():
+    return json.loads(PLUGIN_JSON.read_text(encoding="utf-8"))
+
+
+@pytest.fixture(scope="session")
+def skill_dirs():
+    """Return list of skill directory paths that contain SKILL.md."""
+    return sorted(
+        d for d in SKILLS_DIR.iterdir()
+        if d.is_dir() and (d / "SKILL.md").is_file()
+    )
+
+
+@pytest.fixture(scope="session")
+def rule_files():
+    """Return list of .mdc rule file paths."""
+    return sorted(RULES_DIR.glob("*.mdc"))
+
+
+@pytest.fixture(scope="session")
+def skill_count(skill_dirs):
+    return len(skill_dirs)
+
+
+@pytest.fixture(scope="session")
+def rule_count(rule_files):
+    return len(rule_files)
+
+
+@pytest.fixture(scope="session")
+def readme_text():
+    return (REPO_ROOT / "README.md").read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="session")
+def claude_text():
+    return (REPO_ROOT / "CLAUDE.md").read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="session")
+def contributing_text():
+    return (REPO_ROOT / "CONTRIBUTING.md").read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="session")
+def changelog_text():
+    return (REPO_ROOT / "CHANGELOG.md").read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="session")
+def roadmap_text():
+    return (REPO_ROOT / "ROADMAP.md").read_text(encoding="utf-8")

tests/test_docs_consistency.py

@@ -0,0 +1,137 @@
+"""Verify version and count consistency across all documentation files."""
+
+import re
+
+from conftest import REPO_ROOT
+
+
+# ── Helpers ─────────────────────────────────────────────────────────
+
+
+def _extract_numbers(pattern, text):
+    """Extract all integer matches for a regex with one capture group."""
+    return [int(m) for m in re.findall(pattern, text)]
+
+
+# ── Version Consistency ─────────────────────────────────────────────
+
+
+class TestVersionConsistency:
+    def test_readme_badge_version(self, plugin_manifest, readme_text):
+        version = plugin_manifest["version"]
+        assert f"version-{version}-green" in readme_text, (
+            f"README badge does not show version {version}"
+        )
+
+    def test_roadmap_current_version(self, plugin_manifest, roadmap_text):
+        version = plugin_manifest["version"]
+        assert f"v{version}" in roadmap_text and "Current" in roadmap_text, (
+            f"ROADMAP.md does not list v{version} as current"
+        )
+
+    def test_claude_md_version(self, plugin_manifest, claude_text):
+        version = plugin_manifest["version"]
+        assert f"v{version}" in claude_text or version in claude_text, (
+            f"CLAUDE.md does not mention version {version}"
+        )
+
+    def test_changelog_has_current_version(self, plugin_manifest, changelog_text):
+        version = plugin_manifest["version"]
+        assert f"[{version}]" in changelog_text, (
+            f"CHANGELOG.md has no entry for version {version}"
+        )
+
+
+# ── Skill Count Consistency ─────────────────────────────────────────
+
+
+class TestSkillCountConsistency:
+    def test_readme_skill_count(self, skill_count, readme_text):
+        m = re.search(r"(?:\*\*|<strong>)(\d+)\s+skills(?:\*\*|</strong>)", readme_text)
+        assert m, "README.md stats line missing skill count"
+        assert int(m.group(1)) == skill_count, (
+            f"README says {m.group(1)} skills, disk has {skill_count}"
+        )
+
+    def test_claude_md_skill_count(self, skill_count, claude_text):
+        m = re.search(r"Skills\s*\((\d+)\s+total\)", claude_text)
+        assert m, "CLAUDE.md missing skills total in header"
+        assert int(m.group(1)) == skill_count, (
+            f"CLAUDE.md says {m.group(1)} skills, disk has {skill_count}"
+        )
+
+    def test_contributing_skill_count(self, skill_count, contributing_text):
+        m = re.search(r"\*\*(\d+)\s+skills\*\*", contributing_text)
+        assert m, "CONTRIBUTING.md missing skill count"
+        assert int(m.group(1)) == skill_count, (
+            f"CONTRIBUTING.md says {m.group(1)} skills, disk has {skill_count}"
+        )
+
+
+# ── Rule Count Consistency ──────────────────────────────────────────
+
+
+class TestRuleCountConsistency:
+    def test_readme_rule_count(self, rule_count, readme_text):
+        m = re.search(r"(?:\*\*|<strong>)(\d+)\s+rules(?:\*\*|</strong>)", readme_text)
+        assert m, "README.md stats line missing rule count"
+        assert int(m.group(1)) == rule_count, (
+            f"README says {m.group(1)} rules, disk has {rule_count}"
+        )
+
+    def test_claude_md_rule_count(self, rule_count, claude_text):
+        m = re.search(r"Rules\s*\((\d+)\s+total\)", claude_text)
+        assert m, "CLAUDE.md missing rules total in header"
+        assert int(m.group(1)) == rule_count, (
+            f"CLAUDE.md says {m.group(1)} rules, disk has {rule_count}"
+        )
+
+    def test_contributing_rule_count(self, rule_count, contributing_text):
+        m = re.search(r"\*\*(\d+)\s+rules\*\*", contributing_text)
+        assert m, "CONTRIBUTING.md missing rule count"
+        assert int(m.group(1)) == rule_count, (
+            f"CONTRIBUTING.md says {m.group(1)} rules, disk has {rule_count}"
+        )
+
+
+# ── Feature Table Coverage ──────────────────────────────────────────
+
+
+class TestFeatureTableCoverage:
+    def _name_found_in_text(self, kebab_name: str, text_lower: str) -> bool:
+        """Check if a kebab-case component name appears in text under any variant."""
+        if kebab_name in text_lower:
+            return True
+        stripped = kebab_name.replace("steam-", "").replace("steamworks-", "")
+        words = stripped.split("-")
+        spaced = " ".join(words)
+        if spaced in text_lower:
+            return True
+        titled = " ".join(w.capitalize() for w in words)
+        if titled.lower() in text_lower:
+            return True
+        hyphenated = "-".join(words)
+        if hyphenated in text_lower:
+            return True
+        for i in range(len(words)):
+            for j in range(i + 1, len(words) + 1):
+                chunk = " ".join(words[i:j])
+                if len(chunk) >= 6 and chunk in text_lower:
+                    return True
+        return False
+
+    def test_all_skills_in_readme(self, skill_dirs, readme_text):
+        readme_lower = readme_text.lower()
+        for skill_dir in skill_dirs:
+            name = skill_dir.name
+            assert self._name_found_in_text(name, readme_lower), (
+                f"skill '{name}' not found in README features table"
+            )
+
+    def test_all_rules_in_readme(self, rule_files, readme_text):
+        readme_lower = readme_text.lower()
+        for rule_file in rule_files:
+            stem = rule_file.stem
+            assert self._name_found_in_text(stem, readme_lower), (
+                f"rule '{stem}' not found in README features table"
+            )

tests/test_internal_links.py

@@ -0,0 +1,69 @@
+"""Verify all relative markdown links in .md and .mdc files resolve to existing files."""
+
+import re
+from pathlib import Path
+
+import pytest
+
+from conftest import REPO_ROOT
+
+
+LINK_PATTERN = re.compile(r"\[([^\]]*)\]\(([^)]+)\)")
+HTTP_PATTERN = re.compile(r"^https?://")
+ANCHOR_PATTERN = re.compile(r"^#")
+
+
+def _collect_md_files():
+    """Find all .md and .mdc files in the repo."""
+    files = list(REPO_ROOT.rglob("*.md"))
+    files += list(REPO_ROOT.rglob("*.mdc"))
+    files = [f for f in files if ".git" not in f.parts and "node_modules" not in f.parts]
+    return sorted(files)
+
+
+MD_FILES = _collect_md_files()
+
+
+def _extract_relative_links(filepath: Path) -> list[tuple[str, str, Path]]:
+    """Extract (link_text, raw_path, resolved_target) for relative links."""
+    text = filepath.read_text(encoding="utf-8")
+    results = []
+    for match in LINK_PATTERN.finditer(text):
+        link_text, raw_path = match.groups()
+        if HTTP_PATTERN.match(raw_path):
+            continue
+        if ANCHOR_PATTERN.match(raw_path):
+            continue
+        if raw_path.startswith("mailto:"):
+            continue
+        clean = raw_path.split("#")[0].split("?")[0]
+        if not clean:
+            continue
+        target = (filepath.parent / clean).resolve()
+        results.append((link_text, raw_path, target))
+    return results
+
+
+def _build_test_cases():
+    """Build (file, link_text, raw_path, target) tuples for parametrization."""
+    cases = []
+    for md_file in MD_FILES:
+        for link_text, raw_path, target in _extract_relative_links(md_file):
+            rel = md_file.relative_to(REPO_ROOT)
+            cases.append(pytest.param(
+                md_file, link_text, raw_path, target,
+                id=f"{rel}::[{link_text}]({raw_path})"
+            ))
+    return cases
+
+
+LINK_CASES = _build_test_cases()
+
+
+@pytest.mark.skipif(not LINK_CASES, reason="No relative links found")
+@pytest.mark.parametrize("md_file,link_text,raw_path,target", LINK_CASES)
+def test_relative_link_resolves(md_file, link_text, raw_path, target):
+    assert target.exists(), (
+        f"Broken link in {md_file.relative_to(REPO_ROOT)}: "
+        f"[{link_text}]({raw_path}) -> {target}"
+    )