pl-e2e-test 0.1.3__tar.gz → 0.1.5__tar.gz

{pl_e2e_test-0.1.3/src/pl_e2e_test.egg-info → pl_e2e_test-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-e2e-test
-Version: 0.1.3
+Version: 0.1.5
 Summary: Fuzz PrairieLearn question lifecycles against the real Python element runtime
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/PrairieLearn/pl-e2e-test
@@ -255,16 +255,43 @@ element controllers are archived into the test run's temporary directory. Standa
 cache environment settings such as `XDG_CACHE_HOME` can relocate the managed cache;
 CI systems can persist that directory between runs if desired.
 
+### Harness configuration
+
+Selector settings are read automatically from the course's `pyproject.toml`:
+
+```toml
+[tool.pl-e2e-test]
+elementSolutionSelectors = ["pl-sketch"]
+nonGradableSelectors = ['pl-sketch[read-only="true"]', 'pl-sketch[read-only="1"]']
+```
+
+These are the defaults. `elementSolutionSelectors` identifies elements that provide
+solutions without a `correct_answers` entry. `nonGradableSelectors` excludes
+display-only answers from grading checks. Each supplied list replaces its default;
+omitted settings keep their defaults, and `[]` disables a list.
+
+Use `--config path/to/settings.toml` to select another TOML file with the same
+`[tool.pl-e2e-test]` table. This works with normal runs, `diff`, and arguments after
+`parallel run` or `parallel diff`. Explicit paths are relative to the working directory.
+
 ### Question-local configuration
 
-Store saved concrete seeds and narrow phase skips in `.question-e2e.json` beside the
-question's `info.json`:
+Store saved concrete seeds, narrow phase skips, and expected upstream errors in
+`.question-e2e.json` beside the question's `info.json`:
 
 ```json
 {
   "regression_seeds": [1843927501],
   "skip_methods": {
     "grade": "Temporarily blocked by an upstream issue"
+  },
+  "expected_errors": {
+    "render": [
+      {
+        "match": "^render: known upstream failure$",
+        "reason": "https://github.com/PrairieLearn/PrairieLearn/issues/12345"
+      }
+    ]
   }
 }
 ```
@@ -273,6 +300,21 @@ Saved regression seeds run before newly generated seeds. Skips require a nonempt
 reason and may name only `generate`, `prepare`, `render`, or `grade`. Manual-grading
 questions automatically skip only the grade check.
 
+Prefer `expected_errors` to a skip when the lifecycle can run far enough to expose a
+known upstream defect. Each rule requires a human-readable reason or issue URL and
+exactly one matcher: either `type`, containing a fully qualified exception type, or
+`match`, containing a Python regular expression searched against the exception message.
+A matching exception is reported as `XFAIL`; a different exception fails normally,
+while seeds that do not raise an exception pass normally. A method may not be both
+skipped and expected to fail.
+
+Rules under one method are alternatives. At least one rule must match across the selected
+seeds for that question and method, or an otherwise-successful run fails an audit asking
+you to remove or update the stale expectation. Parallel runs perform this audit after
+merging all shards. Because one upstream error can prevent later code from running,
+obsolete individual alternatives cannot be detected while another alternative still
+matches.
+
 Record the concrete seed shown in a failing pytest case with:
 
 ```sh
@@ -331,6 +373,11 @@ from prairielearn_e2e import PrairieLearnBackend, QuestionCase, QuestionHarness
 increasingly complete portions of the lifecycle. `run_variant` remains an alias for
 the complete grade path.
 
+Pass `config=load_config(course_root=course_root)` to `QuestionHarness` to load the
+course's TOML settings, or `config=load_config("settings.toml")` for an explicit file.
+`load_config` and `HarnessConfig` are exported from `prairielearn_e2e`. Omitting
+`config` uses the built-in defaults.
+
 ## Development
 
 This project uses uv 0.9 or newer:

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5}/README.md

@@ -231,16 +231,43 @@ element controllers are archived into the test run's temporary directory. Standa
 cache environment settings such as `XDG_CACHE_HOME` can relocate the managed cache;
 CI systems can persist that directory between runs if desired.
 
+### Harness configuration
+
+Selector settings are read automatically from the course's `pyproject.toml`:
+
+```toml
+[tool.pl-e2e-test]
+elementSolutionSelectors = ["pl-sketch"]
+nonGradableSelectors = ['pl-sketch[read-only="true"]', 'pl-sketch[read-only="1"]']
+```
+
+These are the defaults. `elementSolutionSelectors` identifies elements that provide
+solutions without a `correct_answers` entry. `nonGradableSelectors` excludes
+display-only answers from grading checks. Each supplied list replaces its default;
+omitted settings keep their defaults, and `[]` disables a list.
+
+Use `--config path/to/settings.toml` to select another TOML file with the same
+`[tool.pl-e2e-test]` table. This works with normal runs, `diff`, and arguments after
+`parallel run` or `parallel diff`. Explicit paths are relative to the working directory.
+
 ### Question-local configuration
 
-Store saved concrete seeds and narrow phase skips in `.question-e2e.json` beside the
-question's `info.json`:
+Store saved concrete seeds, narrow phase skips, and expected upstream errors in
+`.question-e2e.json` beside the question's `info.json`:
 
 ```json
 {
   "regression_seeds": [1843927501],
   "skip_methods": {
     "grade": "Temporarily blocked by an upstream issue"
+  },
+  "expected_errors": {
+    "render": [
+      {
+        "match": "^render: known upstream failure$",
+        "reason": "https://github.com/PrairieLearn/PrairieLearn/issues/12345"
+      }
+    ]
   }
 }
 ```
@@ -249,6 +276,21 @@ Saved regression seeds run before newly generated seeds. Skips require a nonempt
 reason and may name only `generate`, `prepare`, `render`, or `grade`. Manual-grading
 questions automatically skip only the grade check.
 
+Prefer `expected_errors` to a skip when the lifecycle can run far enough to expose a
+known upstream defect. Each rule requires a human-readable reason or issue URL and
+exactly one matcher: either `type`, containing a fully qualified exception type, or
+`match`, containing a Python regular expression searched against the exception message.
+A matching exception is reported as `XFAIL`; a different exception fails normally,
+while seeds that do not raise an exception pass normally. A method may not be both
+skipped and expected to fail.
+
+Rules under one method are alternatives. At least one rule must match across the selected
+seeds for that question and method, or an otherwise-successful run fails an audit asking
+you to remove or update the stale expectation. Parallel runs perform this audit after
+merging all shards. Because one upstream error can prevent later code from running,
+obsolete individual alternatives cannot be detected while another alternative still
+matches.
+
 Record the concrete seed shown in a failing pytest case with:
 
 ```sh
@@ -307,6 +349,11 @@ from prairielearn_e2e import PrairieLearnBackend, QuestionCase, QuestionHarness
 increasingly complete portions of the lifecycle. `run_variant` remains an alias for
 the complete grade path.
 
+Pass `config=load_config(course_root=course_root)` to `QuestionHarness` to load the
+course's TOML settings, or `config=load_config("settings.toml")` for an explicit file.
+`load_config` and `HarnessConfig` are exported from `prairielearn_e2e`. Omitting
+`config` uses the built-in defaults.
+
 ## Development
 
 This project uses uv 0.9 or newer:

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pl-e2e-test"
-version = "0.1.3"
+version = "0.1.5"
 description = "Fuzz PrairieLearn question lifecycles against the real Python element runtime"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -37,11 +37,14 @@ pl-e2e-test = "prairielearn_e2e.cli:main"
 [tool.setuptools.packages.find]
 where = ["src"]
 
-[tool.setuptools.package-data]
-prairielearn_e2e = ["config.json"]
-
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+markers = [
+  "generate: question generate-phase lifecycle checks",
+  "prepare: question prepare-phase lifecycle checks",
+  "render: question render-phase lifecycle checks",
+  "grade: question grading lifecycle checks",
+]
 
 [tool.pyright]
 include = ["src/prairielearn_e2e", "tests"]

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5/src/pl_e2e_test.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-e2e-test
-Version: 0.1.3
+Version: 0.1.5
 Summary: Fuzz PrairieLearn question lifecycles against the real Python element runtime
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/PrairieLearn/pl-e2e-test
@@ -255,16 +255,43 @@ element controllers are archived into the test run's temporary directory. Standa
 cache environment settings such as `XDG_CACHE_HOME` can relocate the managed cache;
 CI systems can persist that directory between runs if desired.
 
+### Harness configuration
+
+Selector settings are read automatically from the course's `pyproject.toml`:
+
+```toml
+[tool.pl-e2e-test]
+elementSolutionSelectors = ["pl-sketch"]
+nonGradableSelectors = ['pl-sketch[read-only="true"]', 'pl-sketch[read-only="1"]']
+```
+
+These are the defaults. `elementSolutionSelectors` identifies elements that provide
+solutions without a `correct_answers` entry. `nonGradableSelectors` excludes
+display-only answers from grading checks. Each supplied list replaces its default;
+omitted settings keep their defaults, and `[]` disables a list.
+
+Use `--config path/to/settings.toml` to select another TOML file with the same
+`[tool.pl-e2e-test]` table. This works with normal runs, `diff`, and arguments after
+`parallel run` or `parallel diff`. Explicit paths are relative to the working directory.
+
 ### Question-local configuration
 
-Store saved concrete seeds and narrow phase skips in `.question-e2e.json` beside the
-question's `info.json`:
+Store saved concrete seeds, narrow phase skips, and expected upstream errors in
+`.question-e2e.json` beside the question's `info.json`:
 
 ```json
 {
   "regression_seeds": [1843927501],
   "skip_methods": {
     "grade": "Temporarily blocked by an upstream issue"
+  },
+  "expected_errors": {
+    "render": [
+      {
+        "match": "^render: known upstream failure$",
+        "reason": "https://github.com/PrairieLearn/PrairieLearn/issues/12345"
+      }
+    ]
   }
 }
 ```
@@ -273,6 +300,21 @@ Saved regression seeds run before newly generated seeds. Skips require a nonempt
 reason and may name only `generate`, `prepare`, `render`, or `grade`. Manual-grading
 questions automatically skip only the grade check.
 
+Prefer `expected_errors` to a skip when the lifecycle can run far enough to expose a
+known upstream defect. Each rule requires a human-readable reason or issue URL and
+exactly one matcher: either `type`, containing a fully qualified exception type, or
+`match`, containing a Python regular expression searched against the exception message.
+A matching exception is reported as `XFAIL`; a different exception fails normally,
+while seeds that do not raise an exception pass normally. A method may not be both
+skipped and expected to fail.
+
+Rules under one method are alternatives. At least one rule must match across the selected
+seeds for that question and method, or an otherwise-successful run fails an audit asking
+you to remove or update the stale expectation. Parallel runs perform this audit after
+merging all shards. Because one upstream error can prevent later code from running,
+obsolete individual alternatives cannot be detected while another alternative still
+matches.
+
 Record the concrete seed shown in a failing pytest case with:
 
 ```sh
@@ -331,6 +373,11 @@ from prairielearn_e2e import PrairieLearnBackend, QuestionCase, QuestionHarness
 increasingly complete portions of the lifecycle. `run_variant` remains an alias for
 the complete grade path.
 
+Pass `config=load_config(course_root=course_root)` to `QuestionHarness` to load the
+course's TOML settings, or `config=load_config("settings.toml")` for an explicit file.
+`load_config` and `HarnessConfig` are exported from `prairielearn_e2e`. Omitting
+`config` uses the built-in defaults.
+
 ## Development
 
 This project uses uv 0.9 or newer:

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5}/src/pl_e2e_test.egg-info/SOURCES.txt

@@ -13,11 +13,11 @@ 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
 src/prairielearn_e2e/discovery.py
 src/prairielearn_e2e/errors.py
+src/prairielearn_e2e/expected_errors.py
 src/prairielearn_e2e/fuzz.py
 src/prairielearn_e2e/harness.py
 src/prairielearn_e2e/html_checks.py
@@ -35,6 +35,7 @@ tests/__init__.py
 tests/conftest.py
 tests/stub_git.py
 tests/test_cli.py
+tests/test_config.py
 tests/test_contract.py
 tests/test_discovery.py
 tests/test_fuzz.py
@@ -45,6 +46,7 @@ tests/test_metadata.py
 tests/test_parallel.py
 tests/test_publish_version.py
 tests/test_pytest_plugin.py
+tests/test_question_tests.py
 tests/test_regression.py
 tests/test_reporting.py
 tests/test_repository.py

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5}/src/prairielearn_e2e/__init__.py

@@ -3,6 +3,7 @@
 from importlib.metadata import version
 
 from .backend import PrairieLearnBackend
+from .config import HarnessConfig, load_config
 from .discovery import QuestionCase, discover_questions
 from .harness import LifecycleResult, QuestionHarness
 from .parallel import run_parallel
@@ -10,11 +11,13 @@ from .parallel import run_parallel
 __version__ = version("pl-e2e-test")
 
 __all__ = (
+    "HarnessConfig",
     "LifecycleResult",
     "PrairieLearnBackend",
     "QuestionCase",
     "QuestionHarness",
     "__version__",
     "discover_questions",
+    "load_config",
     "run_parallel",
 )

pl_e2e_test-0.1.5/src/prairielearn_e2e/config.py

@@ -0,0 +1,68 @@
+"""Load harness settings from the course's pyproject.toml."""
+
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class HarnessConfig:
+    element_solution_answer_selectors: tuple[str, ...] = ("pl-sketch",)
+    non_gradable_answer_selectors: tuple[str, ...] = (
+        'pl-sketch[read-only="true"]',
+        'pl-sketch[read-only="1"]',
+    )
+
+
+DEFAULT_CONFIG = HarnessConfig()
+
+
+def load_config(
+    path: str | Path | None = None, *, course_root: str | Path | None = None
+) -> HarnessConfig:
+    """Read [tool.pl-e2e-test], preserving defaults for omitted settings.
+
+    Without an explicit path, look for pyproject.toml in the course root.
+    A missing implicit file is allowed; a missing explicit file is an error.
+    """
+    config_path = (
+        Path(path)
+        if path is not None
+        else Path(course_root or Path.cwd()) / "pyproject.toml"
+    )
+    try:
+        with config_path.open("rb") as config_file:
+            document = tomllib.load(config_file)
+    except FileNotFoundError:
+        if path is not None:
+            raise
+        return DEFAULT_CONFIG
+    tool = document.get("tool", {})
+    if not isinstance(tool, dict):
+        raise TypeError("tool must be a table")
+    config = tool.get("pl-e2e-test", {})
+    if not isinstance(config, dict):
+        raise TypeError("tool.pl-e2e-test must be a table")
+
+    def selectors(key: str, default: tuple[str, ...]) -> tuple[str, ...]:
+        if key not in config:
+            return default
+        values = config[key]
+        if not isinstance(values, list) or any(
+            not isinstance(value, str) or not value.strip() for value in values
+        ):
+            raise TypeError(
+                f"tool.pl-e2e-test.{key} must be an array of non-empty strings"
+            )
+        return tuple(values)
+
+    return HarnessConfig(
+        element_solution_answer_selectors=selectors(
+            "elementSolutionSelectors", DEFAULT_CONFIG.element_solution_answer_selectors
+        ),
+        non_gradable_answer_selectors=selectors(
+            "nonGradableSelectors", DEFAULT_CONFIG.non_gradable_answer_selectors
+        ),
+    )

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5}/src/prairielearn_e2e/discovery.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import random
+import re
 from collections.abc import Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Literal
 
@@ -22,25 +23,49 @@ LIFECYCLE_METHODS: frozenset[str] = frozenset(
 )
 
 
+@dataclass(frozen=True, slots=True)
+class ExpectedError:
+    """One acceptable exception signature for a lifecycle method."""
+
+    reason: str
+    exception_type: str | None = None
+    match: str | None = None
+
+    def matches(self, exception: Exception) -> bool:
+        if self.exception_type is not None:
+            exception_type = type(exception)
+            qualified_type = (
+                f"{exception_type.__module__}.{exception_type.__qualname__}"
+            )
+            return self.exception_type == qualified_type
+        assert self.match is not None
+        return re.search(self.match, str(exception)) is not None
+
+
 @dataclass(frozen=True, slots=True)
 class E2EConfig:
     """Question-local end-to-end test configuration."""
 
     skip_methods: dict[str, str]
     regression_seeds: tuple[int, ...]
+    expected_errors: dict[str, tuple[ExpectedError, ...]] = field(default_factory=dict)
 
 
 def load_e2e_config(config_path: Path) -> E2EConfig:
     """Load and validate a question-local E2E configuration file."""
 
     if not config_path.is_file():
-        return E2EConfig(skip_methods={}, regression_seeds=())
+        return E2EConfig(skip_methods={}, regression_seeds=(), expected_errors={})
 
     config = load_json(config_path)
     if not isinstance(config, dict):
         raise HarnessError(f"{config_path}: top-level JSON value must be an object")
 
-    if unknown_keys := set(config) - {"regression_seeds", "skip_methods"}:
+    if unknown_keys := set(config) - {
+        "expected_errors",
+        "regression_seeds",
+        "skip_methods",
+    }:
         raise HarnessError(
             f"{config_path}: unknown keys: {', '.join(sorted(unknown_keys))}"
         )
@@ -62,6 +87,80 @@ def load_e2e_config(config_path: Path) -> E2EConfig:
             )
         validated_skip_methods[method] = reason.strip()
 
+    expected_errors = config.get("expected_errors", {})
+    if not isinstance(expected_errors, dict):
+        raise HarnessError(f"{config_path}: expected_errors must be an object")
+    if unknown_methods := set(expected_errors) - LIFECYCLE_METHODS:
+        raise HarnessError(
+            f"{config_path}: unknown expected-error methods: "
+            f"{', '.join(sorted(unknown_methods))}"
+        )
+    if conflicts := set(expected_errors) & set(validated_skip_methods):
+        raise HarnessError(
+            f"{config_path}: methods cannot be both skipped and expected to fail: "
+            f"{', '.join(sorted(conflicts))}"
+        )
+
+    validated_expected_errors: dict[str, tuple[ExpectedError, ...]] = {}
+    allowed_rule_keys = {"type", "match", "reason"}
+    for method, rules in expected_errors.items():
+        context = f"{config_path}: expected_errors[{method!r}]"
+        if not isinstance(rules, list) or not rules:
+            raise HarnessError(f"{context} must be a non-empty array")
+        validated_rules: list[ExpectedError] = []
+        for index, rule in enumerate(rules):
+            rule_context = f"{context}[{index}]"
+            if not isinstance(rule, dict):
+                raise HarnessError(f"{rule_context} must be an object")
+            if unknown_rule_keys := set(rule) - allowed_rule_keys:
+                raise HarnessError(
+                    f"{rule_context} has unknown keys: "
+                    f"{', '.join(sorted(unknown_rule_keys))}"
+                )
+            if "reason" not in rule:
+                raise HarnessError(f"{rule_context} is missing key: reason")
+            has_type = "type" in rule
+            has_match = "match" in rule
+            if has_type == has_match:
+                raise HarnessError(
+                    f"{rule_context} must contain exactly one of type or match"
+                )
+            exception_type = rule.get("type")
+            match = rule.get("match")
+            reason = rule["reason"]
+            if has_type:
+                if not isinstance(exception_type, str):
+                    raise HarnessError(
+                        f"{rule_context}.type must be a fully qualified exception type"
+                    )
+                type_parts = exception_type.strip().split(".")
+                if len(type_parts) < 2 or not all(
+                    part.isidentifier() for part in type_parts
+                ):
+                    raise HarnessError(
+                        f"{rule_context}.type must be a fully qualified exception type"
+                    )
+                exception_type = exception_type.strip()
+            else:
+                if not isinstance(match, str) or not match:
+                    raise HarnessError(
+                        f"{rule_context}.match must be a non-empty string"
+                    )
+                try:
+                    re.compile(match)
+                except re.error as exc:
+                    raise HarnessError(
+                        f"{rule_context}.match is not a valid regular expression: {exc}"
+                    ) from exc
+            if not isinstance(reason, str) or not reason.strip():
+                raise HarnessError(f"{rule_context}.reason must be a non-empty string")
+            validated_rules.append(
+                ExpectedError(
+                    reason=reason.strip(), exception_type=exception_type, match=match
+                )
+            )
+        validated_expected_errors[method] = tuple(validated_rules)
+
     regression_seeds = config.get("regression_seeds", [])
     if not isinstance(regression_seeds, list):
         raise HarnessError(f"{config_path}: regression_seeds must be an array")
@@ -88,6 +187,7 @@ def load_e2e_config(config_path: Path) -> E2EConfig:
     return E2EConfig(
         skip_methods=validated_skip_methods,
         regression_seeds=tuple(validated_regression_seeds),
+        expected_errors=validated_expected_errors,
     )
 
 
@@ -126,6 +226,9 @@ class QuestionCase:
     def e2e_skip_reason(self, method: LifecycleMethod) -> str | None:
         return self.e2e_config().skip_methods.get(method)
 
+    def e2e_expected_errors(self, method: LifecycleMethod) -> tuple[ExpectedError, ...]:
+        return self.e2e_config().expected_errors.get(method, ())
+
     def unvalidated_metadata(self) -> dict[str, Any]:
         value = load_json(self.info_path)
         return value if isinstance(value, dict) else {}

pl_e2e_test-0.1.5/src/prairielearn_e2e/expected_errors.py

@@ -0,0 +1,62 @@
+"""Session-level accounting for configured expected upstream errors."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True, slots=True)
+class ExpectedErrorGroup:
+    """A question lifecycle method whose expected errors are alternatives."""
+
+    group_id: str
+    question: str
+    method: str
+    config_path: str
+
+    def payload(self) -> dict[str, str]:
+        return {
+            "id": self.group_id,
+            "question": self.question,
+            "method": self.method,
+            "config_path": self.config_path,
+        }
+
+
+@dataclass(slots=True)
+class ExpectedErrorAudit:
+    """Track expected-error groups reached and observed during one pytest run."""
+
+    required: dict[str, ExpectedErrorGroup] = field(default_factory=dict)
+    matched: set[str] = field(default_factory=set)
+
+    def require(
+        self, *, question: str, method: str, config_path: str
+    ) -> ExpectedErrorGroup:
+        group_id = f"{question}::{method}"
+        group = ExpectedErrorGroup(group_id, question, method, config_path)
+        existing = self.required.setdefault(group_id, group)
+        if existing != group:
+            raise ValueError(f"conflicting expected-error group {group_id!r}")
+        return existing
+
+    def record_match(self, group: ExpectedErrorGroup) -> None:
+        if self.required.get(group.group_id) != group:
+            raise ValueError(
+                f"expected-error group {group.group_id!r} was not registered"
+            )
+        self.matched.add(group.group_id)
+
+    def missing(self) -> tuple[ExpectedErrorGroup, ...]:
+        return tuple(
+            self.required[group_id]
+            for group_id in sorted(set(self.required) - self.matched)
+        )
+
+    def payload(self) -> dict[str, object]:
+        return {
+            "required": [
+                self.required[group_id].payload() for group_id in sorted(self.required)
+            ],
+            "matched": sorted(self.matched),
+        }

{pl_e2e_test-0.1.3 → pl_e2e_test-0.1.5}/src/prairielearn_e2e/fuzz.py

@@ -197,6 +197,9 @@ def positive_integer(value: str) -> int:
 def main(argv: Sequence[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="pl-e2e-test diff", description=__doc__)
     parser.add_argument("--course-root", type=Path)
+    parser.add_argument(
+        "--config", type=Path, help="TOML config (default: COURSE_ROOT/pyproject.toml)"
+    )
     parser.add_argument("--base", default="main", help="base Git ref (default: main)")
     parser.add_argument("--head", default="HEAD", help="head Git ref (default: HEAD)")
     parser.add_argument("--seed-count", type=positive_integer, default=10)
@@ -276,6 +279,9 @@ def main(argv: Sequence[str] | None = None) -> int:
     print(f"Variant seeds: {', '.join(str(seed) for seed in seeds)}")
     replay_arguments = ["pl-e2e-test", "diff", "--fuzz-seed", str(fuzz_seed)]
     test_arguments: list[str] = []
+    if args.config is not None:
+        replay_arguments.extend(("--config", os.fspath(args.config)))
+        test_arguments.extend(("--config", os.fspath(args.config)))
     if args.prairielearn_path is not None:
         replay_arguments.extend(
             ("--prairielearn-path", os.fspath(args.prairielearn_path))