pl-e2e-test 0.2.1__tar.gz → 0.2.2__tar.gz

{pl_e2e_test-0.2.1/src/pl_e2e_test.egg-info → pl_e2e_test-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-e2e-test
-Version: 0.2.1
+Version: 0.2.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
@@ -115,7 +115,7 @@ uv run python scripts/demo_cli.py --list
 ```
 
 The demo covers help and CLI errors plus passing, failing, skipped, xfailed/xpassed,
-warning, collection-error, empty-selection, quiet, verbose, and per-shard progress
+warning, collection-error, empty-selection, quiet, verbose, and aggregate shard progress
 output.
 
 `--fuzz-seeds` creates and reports a random 64-bit master seed. Reproduce the same

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2}/README.md

@@ -89,7 +89,7 @@ uv run python scripts/demo_cli.py --list
 ```
 
 The demo covers help and CLI errors plus passing, failing, skipped, xfailed/xpassed,
-warning, collection-error, empty-selection, quiet, verbose, and per-shard progress
+warning, collection-error, empty-selection, quiet, verbose, and aggregate shard progress
 output.
 
 `--fuzz-seeds` creates and reports a random 64-bit master seed. Reproduce the same

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pl-e2e-test"
-version = "0.2.1"
+version = "0.2.2"
 description = "Fuzz PrairieLearn question lifecycles against the real Python element runtime"
 readme = "README.md"
 requires-python = ">=3.13"

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2}/scripts/demo_cli.py

@@ -144,10 +144,10 @@ def _verbose(color: ColorChoice) -> int:
 
 def _shards(color: ColorChoice) -> int:
     console = make_console(color=color)
-    outcomes = ("passed", "passed", "failed (1)", "passed")
+    outcomes = (True, True, False, True)
     with _shard_progress(console, len(outcomes), disable=False) as complete:
-        for index, outcome in enumerate(outcomes, start=1):
-            complete(index, outcome)
+        for index, succeeded in enumerate(outcomes, start=1):
+            complete(index, succeeded)
     return 1
 
 

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2/src/pl_e2e_test.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-e2e-test
-Version: 0.2.1
+Version: 0.2.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
@@ -115,7 +115,7 @@ uv run python scripts/demo_cli.py --list
 ```
 
 The demo covers help and CLI errors plus passing, failing, skipped, xfailed/xpassed,
-warning, collection-error, empty-selection, quiet, verbose, and per-shard progress
+warning, collection-error, empty-selection, quiet, verbose, and aggregate shard progress
 output.
 
 `--fuzz-seeds` creates and reports a random 64-bit master seed. Reproduce the same

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2}/src/prairielearn_e2e/parallel.py

@@ -16,7 +16,7 @@ from tempfile import TemporaryDirectory
 from typing import IO
 
 from rich.console import Console
-from rich.progress import BarColumn, Progress, TaskID, TaskProgressColumn, TextColumn
+from rich.progress import BarColumn, MofNCompleteColumn, Progress, TextColumn
 from rich.text import Text
 
 from ._options import scan_options
@@ -55,26 +55,45 @@ class _Child:
 @contextmanager
 def _shard_progress(
     console: Console, shard_count: int, *, disable: bool
-) -> Generator[Callable[[int, str], None]]:
-    """Render one parent-owned completion bar for every child shard."""
+) -> Generator[Callable[[int, bool], None]]:
+    """Render one parent-owned aggregate completion bar for child shards."""
 
+    bar = BarColumn(complete_style="green", finished_style="green")
     progress = Progress(
-        TextColumn("Shard {task.fields[index]}/{task.fields[count]}"),
-        BarColumn(),
-        TaskProgressColumn(),
+        TextColumn("Shards"),
+        bar,
+        MofNCompleteColumn(),
         TextColumn("{task.description}"),
         console=console,
         disable=disable,
     )
-    tasks: dict[int, TaskID] = {}
+    completed: set[int] = set()
+    passed = 0
+    failed = 0
     with progress:
-        for index in range(1, shard_count + 1):
-            tasks[index] = progress.add_task(
-                "running", total=1, index=index, count=shard_count
-            )
+        task = progress.add_task("running", total=shard_count)
+
+        def complete(index: int, succeeded: bool) -> None:
+            nonlocal failed, passed
 
-        def complete(index: int, status: str) -> None:
-            progress.update(tasks[index], description=status, completed=1)
+            if index in completed:
+                return
+            completed.add(index)
+            if succeeded:
+                passed += 1
+            else:
+                failed += 1
+                bar.complete_style = "red"
+                bar.finished_style = "red"
+            statuses = [f"{passed} passed"] if passed else []
+            if failed:
+                statuses.append(f"{failed} failed")
+            progress.update(
+                task,
+                completed=len(completed),
+                description=", ".join(statuses),
+                refresh=True,
+            )
 
         yield complete
 
@@ -291,12 +310,10 @@ def run_parallel(
                             child.returncode = child.process.poll()
                         if child.returncode is None:
                             continue
-                        status = (
-                            "passed"
-                            if child.returncode == 0
-                            else f"failed ({child.returncode})"
+                        complete_shard(
+                            child.index,
+                            child.returncode == 0 and child.report.is_file(),
                         )
-                        complete_shard(child.index, status)
                         pending.remove(child)
                     if pending:
                         time.sleep(0.05)

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2}/tests/test_demo_cli.py

@@ -37,7 +37,7 @@ def test_mixed_demo_uses_native_reporter() -> None:
     assert result.stderr == ""
 
 
-def test_shard_demo_has_one_progress_bar_per_shard() -> None:
+def test_shard_demo_has_one_aggregate_progress_bar() -> None:
     result = subprocess.run(
         [sys.executable, SCRIPT, "--color", "never", "shards"],
         check=True,
@@ -45,7 +45,20 @@ def test_shard_demo_has_one_progress_bar_per_shard() -> None:
         text=True,
     )
 
-    for index in range(1, 5):
-        assert f"Shard {index}/4" in result.stdout
-    assert "failed (1)" in result.stdout
+    assert "Shards" in result.stdout
+    assert "4/4" in result.stdout
+    assert "3 passed, 1 failed" in result.stdout
+    assert all(f"Shard {index}/4" not in result.stdout for index in range(1, 5))
     assert "exit status: 1" in result.stdout
+
+
+def test_failed_shard_demo_uses_a_red_aggregate_bar() -> None:
+    result = subprocess.run(
+        [sys.executable, SCRIPT, "--color", "always", "shards"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    assert "\x1b[31m" in result.stdout
+    assert "3 passed, 1 failed" in result.stdout

{pl_e2e_test-0.2.1 → pl_e2e_test-0.2.2}/tests/test_parallel.py

@@ -9,7 +9,7 @@ import sys
 import xml.etree.ElementTree as ET
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, Self, cast
 
 import pytest
 from rich.console import Console
@@ -87,6 +87,87 @@ def test_invalid_count(count: int) -> None:
         run_parallel([], shard_count=count)
 
 
+@pytest.mark.parametrize(
+    ("completions", "descriptions", "styles"),
+    [
+        (
+            [(2, True), (1, True)],
+            ["1 passed", "2 passed"],
+            ["green", "green"],
+        ),
+        (
+            [(3, True), (1, False), (2, True)],
+            ["1 passed", "1 passed, 1 failed", "2 passed, 1 failed"],
+            ["green", "red", "red"],
+        ),
+    ],
+)
+def test_shard_progress_aggregates_and_refreshes_each_completion(
+    monkeypatch: pytest.MonkeyPatch,
+    completions: list[tuple[int, bool]],
+    descriptions: list[str],
+    styles: list[str],
+) -> None:
+    created: list[FakeProgress] = []
+
+    class FakeProgress:
+        def __init__(self, *columns: object, **kwargs: object) -> None:
+            self.columns = columns
+            self.kwargs = kwargs
+            self.added: list[tuple[str, dict[str, object]]] = []
+            self.updates: list[tuple[dict[str, object], object, object]] = []
+            created.append(self)
+
+        def __enter__(self) -> Self:
+            return self
+
+        def __exit__(self, *args: object) -> None:
+            pass
+
+        def add_task(self, description: str, **kwargs: object) -> int:
+            self.added.append((description, kwargs))
+            return 42
+
+        def update(self, task: int, **kwargs: object) -> None:
+            assert task == 42
+            bar = next(
+                column
+                for column in self.columns
+                if isinstance(column, parallel.BarColumn)
+            )
+            self.updates.append((kwargs, bar.complete_style, bar.finished_style))
+
+    monkeypatch.setattr(parallel, "Progress", FakeProgress)
+
+    with parallel._shard_progress(
+        Console(file=io.StringIO()), len(completions), disable=False
+    ) as complete:
+        for index, succeeded in completions:
+            complete(index, succeeded)
+
+    assert len(created) == 1
+    progress = created[0]
+    assert progress.added == [("running", {"total": len(completions)})]
+    assert [update[0]["completed"] for update in progress.updates] == list(
+        range(1, len(completions) + 1)
+    )
+    assert [update[0]["description"] for update in progress.updates] == descriptions
+    assert all(update[0]["refresh"] is True for update in progress.updates)
+    assert [update[1] for update in progress.updates] == styles
+    assert [update[2] for update in progress.updates] == styles
+
+
+def test_shard_progress_can_be_disabled() -> None:
+    output = io.StringIO()
+    console = Console(file=output, force_terminal=True)
+
+    with parallel._shard_progress(console, 2, disable=True) as complete:
+        complete(1, True)
+        complete(2, False)
+
+    assert output.getvalue() == ""
+
+
 class FinishedProcess:
     def __init__(self, status: int):
         self.status = status
@@ -167,10 +248,17 @@ def test_orchestration_and_diagnostics(
     assert all(not path.exists() for path in reports)
     assert "a warning" in output.getvalue()
     assert "hidden success output" not in output.getvalue()
+    rendered = output.getvalue()
     if not terminal:
-        assert "Running 3 shards in parallel" in output.getvalue()
-    for index in range(1, 4):
-        assert (f"Shard {index}/3" in output.getvalue()) is terminal
+        assert "Running 3 shards in parallel" in rendered
+    assert ("Shards" in rendered) is terminal
+    if terminal:
+        assert "3/3" in rendered
+        if failure in {"missing", "launch", "exit"}:
+            assert "2 passed, 1 failed" in rendered
+        else:
+            assert "3 passed" in rendered
+        assert all(f"Shard {index}/3" not in rendered for index in range(1, 4))
     if failure in {"none", "exit"}:
         assert (tmp_path / "combined.xml").is_file()
     if failure == "launch":