pl-e2e-test 0.1.0__tar.gz → 0.1.2__tar.gz

{pl_e2e_test-0.1.0/src/pl_e2e_test.egg-info → pl_e2e_test-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-e2e-test
-Version: 0.1.0
+Version: 0.1.2
 Summary: Fuzz PrairieLearn question lifecycles against the real Python element runtime
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/PrairieLearn/pl-e2e-test
@@ -28,12 +28,16 @@ generate, prepare, render, parse, grade, test, and file phases. It was extracted
 from the `pl-oer-lv102` course so that courses can install one uv-managed tool
 instead of copying the harness and its support scripts.
 
-The package installs the reusable `prairielearn_e2e` Python API and these commands:
+The package installs the reusable `prairielearn_e2e` Python API and a single
+`pl-e2e-test` command:
 
-- `pl-e2e-test` runs the installed lifecycle pytest suite.
-- `pl-e2e-test-diff` fuzzes questions selected from a Git diff.
-- `pl-e2e-add-regression-seed` records a failing concrete variant seed.
-- `pl-e2e-merge-reports` merges parallel shard results into terminal and JUnit reports.
+- `pl-e2e-test` (no command, or any pytest/harness options) runs the installed
+  lifecycle pytest suite.
+- `pl-e2e-test diff` fuzzes questions selected from a Git diff.
+- `pl-e2e-test add-seed` records a failing concrete variant seed.
+- `pl-e2e-test reports` merges parallel shard results into terminal and JUnit reports.
+- `pl-e2e-test version` prints the installed version.
+- `pl-e2e-test help [COMMAND]` prints top-level help, or one command's help.
 
 ## Requirements and installation
 
@@ -105,7 +109,7 @@ same checkout and arguments. Sharded fuzz runs must also use one explicit shared
 merge them into a combined terminal summary and JUnit report:
 
 ```sh
-uv run pl-e2e-merge-reports e2e-reports \
+uv run pl-e2e-test reports e2e-reports \
   --junitxml pl-e2e-results.xml
 ```
 
@@ -161,7 +165,7 @@ jobs:
           merge-multiple: true
       - name: Merge reports
         run: |
-          uv run pl-e2e-merge-reports e2e-reports \
+          uv run pl-e2e-test reports e2e-reports \
             --junitxml pl-e2e-results.xml
       - name: Upload merged JUnit report
         if: ${{ always() }}
@@ -208,7 +212,7 @@ questions automatically skip only the grade check.
 Record the concrete seed shown in a failing pytest case with:
 
 ```sh
-uv run pl-e2e-add-regression-seed \
+uv run pl-e2e-test add-seed \
   questions/chapter/example 1843927501
 ```
 
@@ -221,20 +225,33 @@ The diff runner tests changed question directories. A non-ignored changed file o
 `questions/` selects every question:
 
 ```sh
-uv run pl-e2e-test-diff \
+uv run pl-e2e-test diff \
   --base origin/main \
   --head HEAD \
   --seed-count 10
 ```
 
-Optional repository-relative ignore rules live in `.question-e2e.diffignore` and use
-Git's native ignore syntax. Missing default configuration means that no paths are
-ignored. Pass `--e2ediffignore PATH` to require and use another file. Additional
-arguments are forwarded to pytest.
+Configure optional repository-relative ignore rules in the course's `pyproject.toml`:
+
+```toml
+[tool.pl-e2e-test]
+diffignore = [
+  ".github",
+  "README.md",
+  "*lock.yaml",
+]
+```
+
+Rules use Git's native ignore syntax and are evaluated in order, so later rules may
+negate earlier ones with `!`. A missing `pyproject.toml`, tool table, or `diffignore`
+entry means that no paths are ignored. Additional arguments are forwarded to pytest.
+
+To migrate from `.question-e2e.diffignore`, copy its non-comment rules into the
+`diffignore` array. The former file and `--e2ediffignore` option are no longer used.
 
 In pull-request CI, fetch the base commit before running the command and pass the
 appropriate base and head SHAs. Set `--fuzz-seed` to replay a reported run.
-`pl-e2e-test-diff` accepts the same `--shard` and `--shard-report` options. If a diff
+`pl-e2e-test diff` accepts the same `--shard` and `--shard-report` options. If a diff
 selects no questions, it writes a successful empty shard report so the merge job can
 still verify that every matrix job completed.
 

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/README.md

@@ -5,12 +5,16 @@ generate, prepare, render, parse, grade, test, and file phases. It was extracted
 from the `pl-oer-lv102` course so that courses can install one uv-managed tool
 instead of copying the harness and its support scripts.
 
-The package installs the reusable `prairielearn_e2e` Python API and these commands:
+The package installs the reusable `prairielearn_e2e` Python API and a single
+`pl-e2e-test` command:
 
-- `pl-e2e-test` runs the installed lifecycle pytest suite.
-- `pl-e2e-test-diff` fuzzes questions selected from a Git diff.
-- `pl-e2e-add-regression-seed` records a failing concrete variant seed.
-- `pl-e2e-merge-reports` merges parallel shard results into terminal and JUnit reports.
+- `pl-e2e-test` (no command, or any pytest/harness options) runs the installed
+  lifecycle pytest suite.
+- `pl-e2e-test diff` fuzzes questions selected from a Git diff.
+- `pl-e2e-test add-seed` records a failing concrete variant seed.
+- `pl-e2e-test reports` merges parallel shard results into terminal and JUnit reports.
+- `pl-e2e-test version` prints the installed version.
+- `pl-e2e-test help [COMMAND]` prints top-level help, or one command's help.
 
 ## Requirements and installation
 
@@ -82,7 +86,7 @@ same checkout and arguments. Sharded fuzz runs must also use one explicit shared
 merge them into a combined terminal summary and JUnit report:
 
 ```sh
-uv run pl-e2e-merge-reports e2e-reports \
+uv run pl-e2e-test reports e2e-reports \
   --junitxml pl-e2e-results.xml
 ```
 
@@ -138,7 +142,7 @@ jobs:
           merge-multiple: true
       - name: Merge reports
         run: |
-          uv run pl-e2e-merge-reports e2e-reports \
+          uv run pl-e2e-test reports e2e-reports \
             --junitxml pl-e2e-results.xml
       - name: Upload merged JUnit report
         if: ${{ always() }}
@@ -185,7 +189,7 @@ questions automatically skip only the grade check.
 Record the concrete seed shown in a failing pytest case with:
 
 ```sh
-uv run pl-e2e-add-regression-seed \
+uv run pl-e2e-test add-seed \
   questions/chapter/example 1843927501
 ```
 
@@ -198,20 +202,33 @@ The diff runner tests changed question directories. A non-ignored changed file o
 `questions/` selects every question:
 
 ```sh
-uv run pl-e2e-test-diff \
+uv run pl-e2e-test diff \
   --base origin/main \
   --head HEAD \
   --seed-count 10
 ```
 
-Optional repository-relative ignore rules live in `.question-e2e.diffignore` and use
-Git's native ignore syntax. Missing default configuration means that no paths are
-ignored. Pass `--e2ediffignore PATH` to require and use another file. Additional
-arguments are forwarded to pytest.
+Configure optional repository-relative ignore rules in the course's `pyproject.toml`:
+
+```toml
+[tool.pl-e2e-test]
+diffignore = [
+  ".github",
+  "README.md",
+  "*lock.yaml",
+]
+```
+
+Rules use Git's native ignore syntax and are evaluated in order, so later rules may
+negate earlier ones with `!`. A missing `pyproject.toml`, tool table, or `diffignore`
+entry means that no paths are ignored. Additional arguments are forwarded to pytest.
+
+To migrate from `.question-e2e.diffignore`, copy its non-comment rules into the
+`diffignore` array. The former file and `--e2ediffignore` option are no longer used.
 
 In pull-request CI, fetch the base commit before running the command and pass the
 appropriate base and head SHAs. Set `--fuzz-seed` to replay a reported run.
-`pl-e2e-test-diff` accepts the same `--shard` and `--shard-report` options. If a diff
+`pl-e2e-test diff` accepts the same `--shard` and `--shard-report` options. If a diff
 selects no questions, it writes a successful empty shard report so the merge job can
 still verify that every matrix job completed.
 

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pl-e2e-test"
-version = "0.1.0"
+version = "0.1.2"
 description = "Fuzz PrairieLearn question lifecycles against the real Python element runtime"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -31,10 +31,7 @@ Issues = "https://github.com/PrairieLearn/pl-e2e-test/issues"
 Repository = "https://github.com/PrairieLearn/pl-e2e-test"
 
 [project.scripts]
-pl-e2e-test = "prairielearn_e2e.runner:main"
-pl-e2e-test-diff = "prairielearn_e2e.fuzz:main"
-pl-e2e-add-regression-seed = "prairielearn_e2e.regression:main"
-pl-e2e-merge-reports = "prairielearn_e2e.reporting:main"
+pl-e2e-test = "prairielearn_e2e.cli:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2/src/pl_e2e_test.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-e2e-test
-Version: 0.1.0
+Version: 0.1.2
 Summary: Fuzz PrairieLearn question lifecycles against the real Python element runtime
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/PrairieLearn/pl-e2e-test
@@ -28,12 +28,16 @@ generate, prepare, render, parse, grade, test, and file phases. It was extracted
 from the `pl-oer-lv102` course so that courses can install one uv-managed tool
 instead of copying the harness and its support scripts.
 
-The package installs the reusable `prairielearn_e2e` Python API and these commands:
+The package installs the reusable `prairielearn_e2e` Python API and a single
+`pl-e2e-test` command:
 
-- `pl-e2e-test` runs the installed lifecycle pytest suite.
-- `pl-e2e-test-diff` fuzzes questions selected from a Git diff.
-- `pl-e2e-add-regression-seed` records a failing concrete variant seed.
-- `pl-e2e-merge-reports` merges parallel shard results into terminal and JUnit reports.
+- `pl-e2e-test` (no command, or any pytest/harness options) runs the installed
+  lifecycle pytest suite.
+- `pl-e2e-test diff` fuzzes questions selected from a Git diff.
+- `pl-e2e-test add-seed` records a failing concrete variant seed.
+- `pl-e2e-test reports` merges parallel shard results into terminal and JUnit reports.
+- `pl-e2e-test version` prints the installed version.
+- `pl-e2e-test help [COMMAND]` prints top-level help, or one command's help.
 
 ## Requirements and installation
 
@@ -105,7 +109,7 @@ same checkout and arguments. Sharded fuzz runs must also use one explicit shared
 merge them into a combined terminal summary and JUnit report:
 
 ```sh
-uv run pl-e2e-merge-reports e2e-reports \
+uv run pl-e2e-test reports e2e-reports \
   --junitxml pl-e2e-results.xml
 ```
 
@@ -161,7 +165,7 @@ jobs:
           merge-multiple: true
       - name: Merge reports
         run: |
-          uv run pl-e2e-merge-reports e2e-reports \
+          uv run pl-e2e-test reports e2e-reports \
             --junitxml pl-e2e-results.xml
       - name: Upload merged JUnit report
         if: ${{ always() }}
@@ -208,7 +212,7 @@ questions automatically skip only the grade check.
 Record the concrete seed shown in a failing pytest case with:
 
 ```sh
-uv run pl-e2e-add-regression-seed \
+uv run pl-e2e-test add-seed \
   questions/chapter/example 1843927501
 ```
 
@@ -221,20 +225,33 @@ The diff runner tests changed question directories. A non-ignored changed file o
 `questions/` selects every question:
 
 ```sh
-uv run pl-e2e-test-diff \
+uv run pl-e2e-test diff \
   --base origin/main \
   --head HEAD \
   --seed-count 10
 ```
 
-Optional repository-relative ignore rules live in `.question-e2e.diffignore` and use
-Git's native ignore syntax. Missing default configuration means that no paths are
-ignored. Pass `--e2ediffignore PATH` to require and use another file. Additional
-arguments are forwarded to pytest.
+Configure optional repository-relative ignore rules in the course's `pyproject.toml`:
+
+```toml
+[tool.pl-e2e-test]
+diffignore = [
+  ".github",
+  "README.md",
+  "*lock.yaml",
+]
+```
+
+Rules use Git's native ignore syntax and are evaluated in order, so later rules may
+negate earlier ones with `!`. A missing `pyproject.toml`, tool table, or `diffignore`
+entry means that no paths are ignored. Additional arguments are forwarded to pytest.
+
+To migrate from `.question-e2e.diffignore`, copy its non-comment rules into the
+`diffignore` array. The former file and `--e2ediffignore` option are no longer used.
 
 In pull-request CI, fetch the base commit before running the command and pass the
 appropriate base and head SHAs. Set `--fuzz-seed` to replay a reported run.
-`pl-e2e-test-diff` accepts the same `--shard` and `--shard-report` options. If a diff
+`pl-e2e-test diff` accepts the same `--shard` and `--shard-report` options. If a diff
 selects no questions, it writes a successful empty shard report so the merge job can
 still verify that every matrix job completed.
 

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/src/pl_e2e_test.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/prairielearn_e2e/__init__.py
 src/prairielearn_e2e/__main__.py
 src/prairielearn_e2e/_git.py
 src/prairielearn_e2e/backend.py
+src/prairielearn_e2e/cli.py
 src/prairielearn_e2e/config.json
 src/prairielearn_e2e/config.py
 src/prairielearn_e2e/contract.py
@@ -32,6 +33,7 @@ src/prairielearn_e2e/sharding.py
 tests/__init__.py
 tests/conftest.py
 tests/stub_git.py
+tests/test_cli.py
 tests/test_contract.py
 tests/test_discovery.py
 tests/test_fuzz.py

pl_e2e_test-0.1.2/src/pl_e2e_test.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pl-e2e-test = prairielearn_e2e.cli:main

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/src/prairielearn_e2e/__main__.py

@@ -1,3 +1,3 @@
-from .runner import main
+from .cli import main
 
 raise SystemExit(main())

pl_e2e_test-0.1.2/src/prairielearn_e2e/cli.py

@@ -0,0 +1,56 @@
+"""Top-level command dispatch for the ``pl-e2e-test`` console script."""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from importlib.metadata import version
+
+from . import fuzz, regression, reporting, runner
+
+_SUBCOMMANDS = {
+    "diff": fuzz.main,
+    "add-seed": regression.main,
+    "reports": reporting.main,
+}
+
+_TOP_LEVEL_HELP = """\
+usage: pl-e2e-test [COMMAND] [ARGS...]
+
+With no COMMAND, runs the installed PrairieLearn question lifecycle test
+suite; any arguments (pytest options, --question-path, --seed-count, ...)
+are passed straight through to pytest.
+
+Commands:
+  diff        fuzz questions changed between two Git refs
+  add-seed    record a concrete regression seed for a question
+  reports     merge parallel shard reports into one terminal/JUnit report
+  version     show the installed pl-e2e-test version
+  help        show this message, or `pl-e2e-test help COMMAND` for one command
+"""
+
+
+def _version_command(_argv: Sequence[str]) -> int:
+    print(f"pl-e2e-test {version('pl-e2e-test')}")
+    return 0
+
+
+def _help_command(argv: Sequence[str]) -> int:
+    if argv and argv[0] in _SUBCOMMANDS:
+        return _SUBCOMMANDS[argv[0]](["--help"])
+    print(_TOP_LEVEL_HELP, end="")
+    return 0
+
+
+_COMMANDS = {**_SUBCOMMANDS, "version": _version_command, "help": _help_command}
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    if arguments and arguments[0] in _COMMANDS:
+        return _COMMANDS[arguments[0]](arguments[1:])
+    return runner.main(arguments)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/src/prairielearn_e2e/fuzz.py

@@ -7,6 +7,7 @@ import os
 import secrets
 import shlex
 import subprocess
+import tomllib
 from collections.abc import Sequence
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -17,7 +18,7 @@ from .runner import run_tests
 from .sharding import Shard, parse_shard
 
 QUESTIONS_ROOT = Path("questions")
-DEFAULT_E2E_DIFF_IGNORE = Path(".question-e2e.diffignore")
+PYPROJECT_CONFIG = Path("pyproject.toml")
 
 
 def git_repository_root(start: Path) -> Path:
@@ -32,18 +33,37 @@ def git_repository_root(start: Path) -> Path:
     return Path(result.stdout.strip()).resolve()
 
 
-def load_e2e_diff_ignore(config_path: Path, *, missing_ok: bool = False) -> list[str]:
-    """Load Git-style ignore rules used by E2E change detection."""
+def load_e2e_diff_ignore(config_path: Path) -> list[str]:
+    """Load Git-style ignore rules from a course's pyproject.toml."""
 
     try:
-        return config_path.read_text(encoding="utf-8").splitlines()
+        with config_path.open("rb") as config_file:
+            config = tomllib.load(config_file)
     except FileNotFoundError:
-        if missing_ok:
-            return []
-        raise ValueError(f"Unable to read {config_path}: file does not exist") from None
+        return []
+    except tomllib.TOMLDecodeError as exc:
+        raise ValueError(f"Unable to read {config_path}: invalid TOML: {exc}") from exc
     except OSError as exc:
         raise ValueError(f"Unable to read {config_path}: {exc}") from exc
 
+    tool_config = config.get("tool", {})
+    if not isinstance(tool_config, dict):
+        raise TypeError(f"Invalid configuration in {config_path}: tool must be a table")
+    e2e_config = tool_config.get("pl-e2e-test", {})
+    if not isinstance(e2e_config, dict):
+        raise TypeError(
+            f"Invalid configuration in {config_path}: tool.pl-e2e-test must be a table"
+        )
+    ignore_rules = e2e_config.get("diffignore", [])
+    if not isinstance(ignore_rules, list) or not all(
+        isinstance(rule, str) for rule in ignore_rules
+    ):
+        raise TypeError(
+            f"Invalid configuration in {config_path}: "
+            "tool.pl-e2e-test.diffignore must be an array of strings"
+        )
+    return ignore_rules
+
 
 def e2e_diff_ignored_files(
     changed_files: Sequence[Path], ignore_rules: Sequence[str]
@@ -175,7 +195,7 @@ def positive_integer(value: str) -> int:
 
 
 def main(argv: Sequence[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
+    parser = argparse.ArgumentParser(prog="pl-e2e-test diff", description=__doc__)
     parser.add_argument("--course-root", type=Path)
     parser.add_argument("--base", default="main", help="base Git ref (default: main)")
     parser.add_argument("--head", default="HEAD", help="head Git ref (default: HEAD)")
@@ -195,8 +215,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     )
     parser.add_argument(
         "--e2ediffignore",
-        type=Path,
-        help="E2E change-detection ignore file (default: COURSE_ROOT/.question-e2e.diffignore)",
+        help=argparse.SUPPRESS,
     )
     parser.add_argument(
         "--shard",
@@ -211,6 +230,11 @@ def main(argv: Sequence[str] | None = None) -> int:
         help="write a mergeable JSON result blob for this shard",
     )
     args, pytest_args = parser.parse_known_args(argv)
+    if args.e2ediffignore is not None:
+        parser.error(
+            "--e2ediffignore has been removed; configure "
+            "tool.pl-e2e-test.diffignore in COURSE_ROOT/pyproject.toml"
+        )
     shard: Shard | None = args.shard
     if args.shard_report is not None and shard is None:
         parser.error("--shard-report requires --shard")
@@ -226,17 +250,9 @@ def main(argv: Sequence[str] | None = None) -> int:
     except (OSError, subprocess.CalledProcessError) as exc:
         parser.error(f"could not find the course Git repository: {exc}")
 
-    ignore_path = args.e2ediffignore
-    if ignore_path is None:
-        ignore_path = repository_root / DEFAULT_E2E_DIFF_IGNORE
-        missing_ok = True
-    else:
-        if not ignore_path.is_absolute():
-            ignore_path = repository_root / ignore_path
-        missing_ok = False
     try:
-        ignored_patterns = load_e2e_diff_ignore(ignore_path, missing_ok=missing_ok)
-    except ValueError as exc:
+        ignored_patterns = load_e2e_diff_ignore(repository_root / PYPROJECT_CONFIG)
+    except (TypeError, ValueError) as exc:
         parser.error(str(exc))
 
     changed_files = changed_files_between(args.base, args.head, repository_root)
@@ -258,7 +274,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     seeds = variant_seeds({}, args.seed_count, fuzz_seed)
     print(f"E2E fuzz seed: {fuzz_seed}")
     print(f"Variant seeds: {', '.join(str(seed) for seed in seeds)}")
-    replay_arguments = ["pl-e2e-test-diff", "--fuzz-seed", str(fuzz_seed)]
+    replay_arguments = ["pl-e2e-test", "diff", "--fuzz-seed", str(fuzz_seed)]
     test_arguments: list[str] = []
     if args.prairielearn_path is not None:
         replay_arguments.extend(

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/src/prairielearn_e2e/regression.py

@@ -96,7 +96,7 @@ def add_regression_seed(course_root: Path, question_path: Path, seed: int) -> bo
 
 
 def main(argv: Sequence[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
+    parser = argparse.ArgumentParser(prog="pl-e2e-test add-seed", description=__doc__)
     parser.add_argument("question_path", type=Path)
     parser.add_argument("variant_seed", type=_variant_seed)
     parser.add_argument("--course-root", type=Path)

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/src/prairielearn_e2e/reporting.py

@@ -659,7 +659,8 @@ def merge_reports(inputs: Sequence[Path], junitxml: Path) -> int:
 
 def main(argv: Sequence[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
-        description="Merge pl-e2e-test shard reports into one terminal and JUnit report."
+        prog="pl-e2e-test reports",
+        description="Merge pl-e2e-test shard reports into one terminal and JUnit report.",
     )
     parser.add_argument("reports", nargs="+", type=Path)
     parser.add_argument("--junitxml", type=Path, default=Path("pl-e2e-results.xml"))
@@ -667,7 +668,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     try:
         return merge_reports(args.reports, args.junitxml)
     except (OSError, ReportError) as exc:
-        print(f"pl-e2e-merge-reports: error: {exc}", file=sys.stderr)
+        print(f"pl-e2e-test reports: error: {exc}", file=sys.stderr)
         return 2
 
 

pl_e2e_test-0.1.2/tests/test_cli.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from importlib.metadata import version
+
+import pytest
+
+from prairielearn_e2e import cli
+
+
+def _stub(calls: list[Sequence[str]], result: int = 0):
+    def _main(argv: Sequence[str]) -> int:
+        calls.append(list(argv))
+        return result
+
+    return _main
+
+
+@pytest.mark.parametrize("command", ["diff", "add-seed", "reports"])
+def test_dispatches_known_commands_to_their_module(
+    monkeypatch: pytest.MonkeyPatch, command: str
+) -> None:
+    calls: list[Sequence[str]] = []
+    monkeypatch.setitem(cli._COMMANDS, command, _stub(calls, result=3))
+
+    assert cli.main([command, "--example", "value"]) == 3
+    assert calls == [["--example", "value"]]
+
+
+def test_no_command_falls_through_to_the_test_runner(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[Sequence[str]] = []
+    monkeypatch.setattr(cli, "runner", type("_Runner", (), {"main": _stub(calls)}))
+
+    assert cli.main(["--question-path", "questions/example", "-k", "sample"]) == 0
+    assert calls == [["--question-path", "questions/example", "-k", "sample"]]
+
+
+def test_bare_invocation_falls_through_to_the_test_runner(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[Sequence[str]] = []
+    monkeypatch.setattr(cli, "runner", type("_Runner", (), {"main": _stub(calls)}))
+
+    assert cli.main([]) == 0
+    assert calls == [[]]
+
+
+def test_version_command_prints_the_installed_version(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    assert cli.main(["version"]) == 0
+    assert capsys.readouterr().out == f"pl-e2e-test {version('pl-e2e-test')}\n"
+
+
+def test_help_command_with_no_argument_prints_top_level_help(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    assert cli.main(["help"]) == 0
+    out = capsys.readouterr().out
+    assert "Commands:" in out
+    for command in ("diff", "add-seed", "reports", "version", "help"):
+        assert command in out
+
+
+def test_help_command_delegates_to_a_known_subcommand(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[Sequence[str]] = []
+    monkeypatch.setitem(cli._SUBCOMMANDS, "diff", _stub(calls))
+
+    assert cli.main(["help", "diff"]) == 0
+    assert calls == [["--help"]]
+
+
+def test_help_command_with_unknown_argument_prints_top_level_help(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    assert cli.main(["help", "not-a-command"]) == 0
+    assert "Commands:" in capsys.readouterr().out

{pl_e2e_test-0.1.0 → pl_e2e_test-0.1.2}/tests/test_fuzz.py

@@ -65,14 +65,83 @@ def test_root_anchored_gitignore_pattern() -> None:
     ) == {Path("README.md")}
 
 
-def test_missing_default_ignore_file_is_empty(tmp_path: Path) -> None:
-    assert (
-        fuzz.load_e2e_diff_ignore(
-            tmp_path / ".question-e2e.diffignore", missing_ok=True
-        )
-        == []
+def test_later_gitignore_pattern_can_negate_earlier_pattern() -> None:
+    assert fuzz.e2e_diff_ignored_files(
+        [Path("uv.lock"), Path("required.lock")], ["*.lock", "!required.lock"]
+    ) == {Path("uv.lock")}
+
+
+def test_loads_diff_ignore_from_pyproject(tmp_path: Path) -> None:
+    config_path = tmp_path / "pyproject.toml"
+    config_path.write_text(
+        """
+[tool.pl-e2e-test]
+diffignore = ["/README.md", "*.lock", "!required.lock"]
+""",
+        encoding="utf-8",
     )
 
+    assert fuzz.load_e2e_diff_ignore(config_path) == [
+        "/README.md",
+        "*.lock",
+        "!required.lock",
+    ]
+
+
+@pytest.mark.parametrize(
+    "contents",
+    [
+        "",
+        "[tool.pytest.ini_options]\n",
+        "[tool.pl-e2e-test]\n",
+        "[tool.pl-e2e-test]\ndiffignore = []\n",
+    ],
+)
+def test_missing_or_empty_diff_ignore_configuration_is_empty(
+    tmp_path: Path, contents: str
+) -> None:
+    config_path = tmp_path / "pyproject.toml"
+    config_path.write_text(contents, encoding="utf-8")
+
+    assert fuzz.load_e2e_diff_ignore(config_path) == []
+
+
+def test_missing_pyproject_is_empty(tmp_path: Path) -> None:
+    assert fuzz.load_e2e_diff_ignore(tmp_path / "pyproject.toml") == []
+
+
+def test_invalid_pyproject_is_rejected(tmp_path: Path) -> None:
+    config_path = tmp_path / "pyproject.toml"
+    config_path.write_text("[tool.pl-e2e-test\n", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="invalid TOML"):
+        fuzz.load_e2e_diff_ignore(config_path)
+
+
+def test_unreadable_pyproject_is_rejected(tmp_path: Path) -> None:
+    config_path = tmp_path / "pyproject.toml"
+    config_path.mkdir()
+
+    with pytest.raises(ValueError, match="Unable to read"):
+        fuzz.load_e2e_diff_ignore(config_path)
+
+
+@pytest.mark.parametrize(
+    "configured_value",
+    ['"README.md"', '["README.md", 1]'],
+)
+def test_diff_ignore_must_be_an_array_of_strings(
+    tmp_path: Path, configured_value: str
+) -> None:
+    config_path = tmp_path / "pyproject.toml"
+    config_path.write_text(
+        f"[tool.pl-e2e-test]\ndiffignore = {configured_value}\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(TypeError, match="must be an array of strings"):
+        fuzz.load_e2e_diff_ignore(config_path)
+
 
 def test_main_forwards_selected_questions_and_seed(
     monkeypatch: pytest.MonkeyPatch,
@@ -82,11 +151,16 @@ def test_main_forwards_selected_questions_and_seed(
     question = tmp_path / "questions" / "chapter" / "example"
     question.mkdir(parents=True)
     (question / "info.json").write_text("{}", encoding="utf-8")
+    (tmp_path / "pyproject.toml").write_text(
+        '[tool.pl-e2e-test]\ndiffignore = ["README.md"]\n',
+        encoding="utf-8",
+    )
     monkeypatch.setattr(
         fuzz,
         "changed_files_between",
         lambda base, head, repository_root: [
-            Path("questions/chapter/example/server.py")
+            Path("README.md"),
+            Path("questions/chapter/example/server.py"),
         ],
     )
     calls: list[tuple[list[str], Path]] = []
@@ -131,6 +205,28 @@ def test_main_forwards_selected_questions_and_seed(
     assert "E2E fuzz seed: 12345" in capsys.readouterr().out
 
 
+def test_main_reports_invalid_pyproject(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    (tmp_path / "pyproject.toml").write_text("[tool.pl-e2e-test\n", encoding="utf-8")
+
+    with pytest.raises(SystemExit, match="2"):
+        fuzz.main(["--course-root", str(tmp_path)])
+
+    assert "invalid TOML" in capsys.readouterr().err
+
+
+def test_removed_diff_ignore_option_reports_migration(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit, match="2"):
+        fuzz.main(["--e2ediffignore", ".question-e2e.diffignore"])
+
+    error = capsys.readouterr().err
+    assert "--e2ediffignore has been removed" in error
+    assert "tool.pl-e2e-test.diffignore" in error
+
+
 def test_main_uses_managed_cache_when_prairielearn_path_is_omitted(
     monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
@@ -182,7 +278,7 @@ def test_main_uses_managed_cache_when_prairielearn_path_is_omitted(
         for line in capsys.readouterr().out.splitlines()
         if line.startswith("Replay")
     )
-    assert replay == "Replay with: pl-e2e-test-diff --fuzz-seed 9876"
+    assert replay == "Replay with: pl-e2e-test diff --fuzz-seed 9876"
 
 
 def test_empty_diff_does_not_generate_a_seed(

pl_e2e_test-0.1.0/src/pl_e2e_test.egg-info/entry_points.txt

@@ -1,5 +0,0 @@
-[console_scripts]
-pl-e2e-add-regression-seed = prairielearn_e2e.regression:main
-pl-e2e-merge-reports = prairielearn_e2e.reporting:main
-pl-e2e-test = prairielearn_e2e.runner:main
-pl-e2e-test-diff = prairielearn_e2e.fuzz:main