Report a render that failed on the way out as failed

The success flag is set per module, so a render that fails after an
earlier module has completed is still holding that module's success.
Only the TUI path cleared it, so a headless render that died mid-way
logged outcome=completed next to its own error and an empty generated
code path. It also decides the exit code, which is 0 when the failure
is one of EXPECTED_EXCEPTIONS - so the same render was about to start
exiting 0 once the server returns a typed error for an exhausted fix
loop.

Both paths now record the outcome through one function, and the trailer
and the banner treat a recorded reason as evidence the render did not
complete.

Author: gorandodig

cli_output/render_summary.py

@@ -15,6 +15,20 @@
 RENDER_TRAILER_PREFIX = "[render-trailer]"
 
 
+def render_outcome(run_state: RunState, error_message: Optional[str]) -> str:
+    """What the render did, for the banner and the trailer alike.
+
+    A reason recorded on the way out overrides the success flag. The flag is set per
+    module, so an earlier module's success can still be standing while the process exits
+    on an error - which read as a completed render that produced nothing.
+    """
+    if run_state.render_succeeded and not error_message:
+        return "completed"
+    if run_state.render_cancelled:
+        return "cancelled"
+    return "failed"
+
+
 def print_exit_summary(
     run_state: RunState,
     spec_filename: str,
@@ -23,7 +37,7 @@ def print_exit_summary(
     """Print render outcome after the TUI exits (terminal restored)."""
     console.quiet = False
 
-    if run_state.render_succeeded:
+    if render_outcome(run_state, error_message) == "completed":
         msg = "\n[#79FC96]✓ rendering completed\n\n"
     elif run_state.render_cancelled:
         msg = "\n[#FFFFFF]— rendering canceled\n\n"
@@ -59,12 +73,7 @@ def log_render_trailer(
     the render did, and because it is written on every exit path a log *without* a
     trailer is itself evidence that the file was truncated.
     """
-    if run_state.render_succeeded:
-        outcome = "completed"
-    elif run_state.render_cancelled:
-        outcome = "cancelled"
-    else:
-        outcome = "failed"
+    outcome = render_outcome(run_state, error_message)
 
     # Both times: an action that raises never reaches the render's own terminal accounting,
     # so the banked figure is stale on the paths this trailer exists to describe, and the

plain2code.py

@@ -192,6 +192,25 @@ def warn_if_acceptance_tests_without_conformance_script(plain_module, args) -> N
     )
 
 
+def _render_recording_outcome(module_renderer, run_state: RunState) -> Exception | None:
+    """Runs the render and records how it ended, returning the failure if there was one.
+
+    The outcome is recorded per module, so a render that fails after an earlier module has
+    completed is still holding that module's success. Both the render trailer and the
+    headless exit code read that flag, and the exit code is 0 when the failure is one of
+    EXPECTED_EXCEPTIONS - so a caller that skips this reports a failed render as a
+    successful one.
+    """
+    try:
+        module_renderer.render_module()
+    except RenderCancelledError:
+        run_state.set_render_cancelled()  # The TUI is already closed, nothing to report.
+    except Exception as error:
+        run_state.set_render_succeeded(False)
+        return error
+    return None
+
+
 def render(  # noqa: C901
     plain_module: plain_modules.PlainModule,
     args,
@@ -285,21 +304,16 @@ def render(  # noqa: C901
     render_error: list[Exception] = []
 
     def run_render():
-        try:
-            module_renderer.render_module()
-        except RenderCancelledError:
-            run_state.set_render_cancelled()  # TUI already closed, nothing to report
-        except Exception as e:
-            run_state.set_render_succeeded(False)
-            render_error.append(e)
-            event_bus.publish(RenderFailed(error_message=str(e)))
+        error = _render_recording_outcome(module_renderer, run_state)
+        if error is not None:
+            render_error.append(error)
+            event_bus.publish(RenderFailed(error_message=str(error)))
 
     if args.headless:
         console.info(f"Render started. Render ID: {run_state.render_id}")
-        try:
-            module_renderer.render_module()
-        except RenderCancelledError:
-            run_state.set_render_cancelled()
+        error = _render_recording_outcome(module_renderer, run_state)
+        if error is not None:
+            raise error
         return
     else:
         render_thread = threading.Thread(target=run_render, daemon=True)

tests/test_plain2code.py

@@ -1,10 +1,12 @@
 import tempfile
 from argparse import Namespace
 from types import SimpleNamespace
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import plain2code
 import plain_spec
+from plain2code_exceptions import RenderCancelledError
+from plain2code_state import RunState
 from plain_modules import PlainModule
 
 
@@ -91,3 +93,42 @@ def test_warning_covers_required_modules_for_real_plain_module(get_test_data_pat
     mock_console.warning.assert_called_once()
     warning_message = mock_console.warning.call_args.args[0]
     assert "required_with_acceptance_tests" in warning_message
+
+
+class TestRenderRecordsItsOutcome:
+    """The headless path and the TUI path both have to record how the render ended. Only
+    the TUI path did, so a headless render that failed after one module had completed
+    reported `outcome=completed` and, when the failure was an expected exception, exited 0.
+    """
+
+    @staticmethod
+    def _renderer(error=None):
+        renderer = MagicMock()
+        if error is not None:
+            renderer.render_module.side_effect = error
+        return renderer
+
+    def test_a_failure_clears_a_success_left_by_an_earlier_module(self):
+        run_state = RunState("reports.plain")
+        run_state.set_render_succeeded(True)
+        failure = RuntimeError("conformance fix loop exhausted")
+
+        returned = plain2code._render_recording_outcome(self._renderer(failure), run_state)
+
+        assert returned is failure
+        assert run_state.render_succeeded is False
+
+    def test_a_clean_run_leaves_the_outcome_alone(self):
+        run_state = RunState("reports.plain")
+        run_state.set_render_succeeded(True)
+
+        assert plain2code._render_recording_outcome(self._renderer(), run_state) is None
+        assert run_state.render_succeeded is True
+
+    def test_cancellation_is_recorded_as_cancelled_rather_than_returned(self):
+        run_state = RunState("reports.plain")
+
+        returned = plain2code._render_recording_outcome(self._renderer(RenderCancelledError()), run_state)
+
+        assert returned is None
+        assert run_state.render_cancelled is True

tests/test_render_trailer.py

@@ -104,15 +104,19 @@ def test_the_trailer_is_flushed_so_it_survives_an_abrupt_exit():
     assert handler.flush.called
 
 
-def test_a_completed_render_that_still_raised_reports_the_reason(trailer_lines):
+def test_a_render_that_raised_on_the_way_out_reports_the_reason_and_fails(trailer_lines):
     """A render can finish its functionalities and raise on the way out — publishing the
-    build, for instance. That combination printed a success banner, logged no reason, and
-    exited non-zero, which is how a failure on the publish path went unnoticed across a
-    whole run."""
+    build, for instance. That combination printed a success banner and logged no reason,
+    which is how a failure on the publish path went unnoticed across a whole run.
+
+    The reason belongs on the trailer, and so does an outcome that agrees with it: the
+    success flag is set per module, so an earlier module's success outlives the failure of
+    a later one, and a run that produced no build reported `outcome=completed`."""
     lines = trailer_lines(run_state(succeeded=True), error_message="The generated build references ...")
 
-    assert any("outcome=completed" in line for line in lines)
     assert any("error='The generated build references ...'" in line for line in lines)
+    assert any("outcome=failed" in line for line in lines)
+    assert not any("outcome=completed" in line for line in lines)
 
 
 def test_a_multi_line_reason_still_leaves_the_trailer_on_one_line(trailer_lines):
@@ -124,3 +128,18 @@ def test_a_multi_line_reason_still_leaves_the_trailer_on_one_line(trailer_lines)
     assert "\n" not in lines[0]
     assert "outcome=failed" in lines[0]
     assert "second line" in lines[0]
+
+
+class TestOutcomeAgreesWithTheReason:
+    """A trailer that says `completed` next to an `error=` is worse than no trailer: it is
+    read by tooling, and it was observed on a render that produced no code at all. The
+    success flag is set per module, so an earlier module's success outlives the failure of
+    a later one."""
+
+    def test_success_with_no_error_still_completes(self, trailer_lines):
+        assert "outcome=completed" in trailer_lines(run_state(succeeded=True))[0]
+
+    def test_a_cancelled_render_reports_cancelled_not_failed(self, trailer_lines):
+        lines = trailer_lines(run_state(succeeded=False, cancelled=True), error_message="Keyboard interrupt")
+
+        assert "outcome=cancelled" in lines[0]