llm-tool-cli 0.2.0__py3-none-any.whl

llm_tool_cli/cli/tests/test_application.py

@@ -0,0 +1,167 @@
+import pytest
+import typer
+from pytest_mock import MockerFixture
+from typer.testing import CliRunner
+
+from llm_tool_cli.cli.application import create_app
+from llm_tool_cli.cli.context import CommandContext
+from llm_tool_cli.config.project import project_config
+from llm_tool_cli.config.runtime import RuntimeConfig, runtime_config
+from llm_tool_cli.core.settings import ToolLabel, initialize
+from llm_tool_cli.core.tests.fixtures import isolated_settings
+from llm_tool_cli.protocol import Protocol
+
+__all__ = ["isolated_settings"]
+
+
+@pytest.fixture
+def app() -> typer.Typer:
+    application = create_app(help="Inspect test resources.")
+
+    @application.command(help="Show a test resource.")
+    def show() -> None:
+        raise AssertionError("Help and completion must not execute the command.")
+
+    return application
+
+
+class TestCreateApp:
+    @pytest.mark.parametrize("option", ["-p", "--protocol"])
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    def test_nested_commands_and_repeated_invocations(self, option: str, protocol: Protocol) -> None:
+        application = create_app(help="Inspect nested resources.")
+        group = typer.Typer()
+        application.add_typer(group, name="nested")
+        received: list[RuntimeConfig] = []
+
+        @group.command()
+        def show(context: typer.Context) -> None:
+            command = CommandContext(context)
+            received.append(runtime_config.get())
+            assert command.config_input == context.find_root().params["config_path"]
+            assert context.obj == {"other": "state"}
+            assert context.find_root().meta == {}
+
+        runner = CliRunner()
+        explicit = runner.invoke(
+            application,
+            [option, protocol.value, "--config", "~/custom.toml", "nested", "show"],
+            obj={"other": "state"},
+        )
+        assert not runtime_config.is_set()
+        unspecified = runner.invoke(application, ["nested", "show"], obj={"other": "state"})
+        assert not runtime_config.is_set()
+
+        assert explicit.exit_code == unspecified.exit_code == 0
+        assert explicit.stdout == explicit.stderr == unspecified.stdout == unspecified.stderr == ""
+        assert received == [
+            RuntimeConfig(protocol=protocol),
+            RuntimeConfig(protocol=Protocol.human),
+        ]
+
+    @pytest.mark.parametrize(
+        ("failure", "exit_code"),
+        [(None, 0), (typer.Exit(7), 7), (RuntimeError("command failed"), 1)],
+    )
+    def test_restores_outer_runtime_after_command(self, failure: Exception | None, exit_code: int) -> None:
+        application = create_app(help="Inspect scoped options.")
+        received: list[RuntimeConfig] = []
+
+        @application.command()
+        def show(context: typer.Context) -> None:
+            command = CommandContext(context)
+            received.append(runtime_config.get())
+            assert command.protocol == Protocol.human
+            if failure is not None:
+                raise failure
+
+        outer = RuntimeConfig(protocol=Protocol.automation)
+        with runtime_config.scope(outer):
+            result = CliRunner().invoke(application, ["show"])
+
+            assert result.exit_code == exit_code
+            assert received == [RuntimeConfig(protocol=Protocol.human)]
+            assert runtime_config.get() == outer
+
+        assert not runtime_config.is_set()
+        if failure is not None and not isinstance(failure, typer.Exit):
+            assert isinstance(result.exception, type(failure))
+            assert result.exception.args == failure.args
+
+    def test_subcommand_parse_error_leaves_runtime_unbound(self, app: typer.Typer) -> None:
+        result = CliRunner().invoke(app, ["-p", "automation", "show", "--unknown"])
+
+        assert result.exit_code == 2
+        assert "No such option" in result.stderr
+        assert not runtime_config.is_set()
+
+    def test_invalid_protocol_stops_execution(self, app: typer.Typer, isolated_settings: None) -> None:
+        initialize(label=ToolLabel("TEST"))
+
+        result = CliRunner().invoke(app, ["--protocol", "invalid", "show"])
+
+        assert result.exit_code == 1
+        assert not result.stderr
+        assert result.stdout.startswith("--TEST-CELL ")
+        assert result.stdout.count(" BEGIN--\n") == 1
+        assert "code=invalid_arguments\n" in result.stdout
+        assert not runtime_config.is_set()
+        assert not project_config.is_set()
+
+    @pytest.mark.parametrize("option", ["-p", "--protocol", "--config"])
+    def test_missing_option_value(self, app: typer.Typer, option: str) -> None:
+        result = CliRunner().invoke(app, [option])
+
+        assert result.exit_code == 2
+        assert not result.stdout
+        assert "requires an argument" in result.stderr
+
+    @pytest.mark.parametrize("option", ["-h", "--help"])
+    @pytest.mark.parametrize("command", [[], ["show"]])
+    def test_help_aliases(self, app: typer.Typer, option: str, command: list[str]) -> None:
+        result = CliRunner().invoke(app, [*command, option])
+
+        assert result.exit_code == 0
+        assert not result.stderr
+        assert not runtime_config.is_set()
+        assert ("Show a test resource." if command else "Inspect test resources.") in result.stdout
+        assert "--help" in result.stdout
+        assert "-h" in result.stdout
+        if not command:
+            assert "--protocol" in result.stdout
+            assert "-p" in result.stdout
+            assert "--config" in result.stdout
+            assert "--show-completion" in result.stdout
+            assert "--install-completion" in result.stdout
+
+    def test_show_completion_does_not_install(self, app: typer.Typer, mocker: MockerFixture) -> None:
+        mocker.patch("typer.completion._get_shell_name", return_value="bash")
+        install = mocker.patch("typer.completion.install")
+
+        result = CliRunner().invoke(app, ["--show-completion"], prog_name="sample")
+
+        assert result.exit_code == 0
+        assert not result.stderr
+        assert "_SAMPLE_COMPLETE" in result.stdout
+        assert "complete" in result.stdout
+        install.assert_not_called()
+
+    def test_install_completion_is_explicit(self, app: typer.Typer, mocker: MockerFixture) -> None:
+        install = mocker.patch("typer.completion.install", return_value=("bash", "/test/completion.sh"))
+
+        assert CliRunner().invoke(app, ["--help"]).exit_code == 0
+        install.assert_not_called()
+
+        result = CliRunner().invoke(app, ["--install-completion"])
+
+        assert result.exit_code == 0
+        assert not result.stderr
+        install.assert_called_once_with()
+
+    def test_applications_have_independent_commands(self, app: typer.Typer) -> None:
+        other = create_app(help="Other resources.")
+
+        result = CliRunner().invoke(other, ["show"])
+
+        assert result.exit_code == 2
+        assert "No such command" in result.stderr

llm_tool_cli/cli/tests/test_context.py

@@ -0,0 +1,179 @@
+import io
+import json
+from pathlib import Path
+
+import pytest
+import typer
+from typer.core import TyperCommand
+from typer.testing import CliRunner
+
+from llm_tool_cli.cli.application import create_app
+from llm_tool_cli.cli.context import CommandContext, command_context
+from llm_tool_cli.cli.errors import InvalidArguments
+from llm_tool_cli.config.project import ProjectConfig, project_config
+from llm_tool_cli.config.runtime import RuntimeConfig, runtime_config
+from llm_tool_cli.core.result import UnwrapError
+from llm_tool_cli.core.settings import ToolLabel, initialize
+from llm_tool_cli.core.tests.fixtures import isolated_settings
+from llm_tool_cli.output import StreamOutputEmitter
+from llm_tool_cli.output import output as active_output
+from llm_tool_cli.output.tests.helpers import CollectingEmitter
+from llm_tool_cli.paths import ProjectConfigPath
+from llm_tool_cli.protocol import Protocol
+from llm_tool_cli.protocol.cell_shortcuts import info, operation_succeeded
+from llm_tool_cli.protocol.logic_cells.base import LogicCell
+from llm_tool_cli.protocol.logic_cells.warning import WarningCell
+
+__all__ = ["isolated_settings"]
+
+
+@pytest.mark.usefixtures("isolated_settings")
+class TestCommandContext:
+    def test_command_scope_without_project_flushes_and_restores_output(
+        self, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+        previous = CollectingEmitter()
+        with active_output.scope(previous):
+            with typer.Context(TyperCommand("show")) as context:
+                with command_context(context):
+                    assert not project_config.is_set()
+                    active_output.get().emit([info("Without a project")]).unwrap()
+                    assert not capsys.readouterr().out
+                assert "Without a project" in capsys.readouterr().out
+            assert active_output.get() == previous
+        assert not previous.cells
+        assert not active_output.is_set()
+        assert not runtime_config.is_set()
+
+    @pytest.mark.parametrize(
+        "failure, exit_code, record_types",
+        [
+            (None, 0, ["operation_succeeded", "warning"]),
+            (UnwrapError(error=[InvalidArguments(reason="Invalid input")]), 1, ["error", "warning"]),
+            (RuntimeError("Unexpected failure"), 1, []),
+            (typer.Exit(7), 7, []),
+        ],
+    )
+    def test_command_scope_finalizes_using_active_emitter_before_framework_cleanup(
+        self, tmp_path: Path, failure: Exception | None, exit_code: int, record_types: list[str]
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+        project = ProjectConfig(config_path=ProjectConfigPath(tmp_path / "active.toml"))
+        stream = io.StringIO()
+        rendered: list[list[LogicCell]] = []
+
+        class ProjectEmitter(StreamOutputEmitter):
+            def _render(self, cells: list[LogicCell]) -> str:
+                assert project_config.get() == project
+                assert runtime_config.get().protocol == Protocol.automation
+                rendered.append(cells)
+                return super()._render(cells)
+
+        app = create_app(help="Exercise command finalization.")
+
+        @app.command()
+        def show(context: typer.Context) -> None:
+            with command_context(context):
+                context.with_resource(project_config.scope(project))
+                context.with_resource(active_output.scope(ProjectEmitter(stream=stream)))
+                active_output.get().emit([WarningCell(message="A warning")]).unwrap()
+                active_output.get().emit([operation_succeeded("Completed")]).unwrap()
+                assert not stream.getvalue()
+                if failure is not None:
+                    raise failure
+
+        previous_output = CollectingEmitter()
+        previous_runtime = RuntimeConfig(protocol=Protocol.llm)
+        previous_project = ProjectConfig(config_path=ProjectConfigPath(tmp_path / "outer.toml"))
+        with (
+            active_output.scope(previous_output),
+            runtime_config.scope(previous_runtime),
+            project_config.scope(previous_project),
+        ):
+            result = CliRunner().invoke(app, ["-p", "automation", "show"])
+            assert active_output.get() == previous_output
+            assert runtime_config.get() == previous_runtime
+            assert project_config.get() == previous_project
+
+        assert result.exit_code == exit_code, result.exception
+        assert not result.stdout
+        assert not result.stderr
+        assert [json.loads(line)["type"] for line in stream.getvalue().splitlines()] == record_types
+        assert bool(rendered) == bool(record_types)
+        assert not previous_output.cells
+        if failure is not None and not isinstance(failure, (typer.Exit, UnwrapError)):
+            assert result.exception == failure
+
+    def test_init__nested_skill_uses_leaf_command_default(self) -> None:
+        with typer.Context(TyperCommand("root")) as root:
+            with typer.Context(TyperCommand("group"), parent=root) as group:
+                with typer.Context(TyperCommand("skill"), parent=group, info_name="skill") as context:
+                    assert CommandContext(context).protocol == Protocol.llm
+
+    @pytest.mark.parametrize(
+        ("name", "expected"),
+        [("skill", Protocol.llm), ("version", Protocol.human), ("alias", Protocol.human), (None, Protocol.human)],
+    )
+    def test_init__selects_default_for_invoked_name(self, name: str | None, expected: Protocol) -> None:
+        with typer.Context(TyperCommand("different-name"), info_name=name) as context:
+            command = CommandContext(context)
+            assert command.protocol == expected
+            assert command.config_input is None
+            assert not project_config.is_set()
+            assert context.meta == {}
+        assert not runtime_config.is_set()
+
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    def test_init__uses_root_inputs_for_nested_command(self, protocol: Protocol) -> None:
+        with typer.Context(TyperCommand("root")) as root:
+            root.params.update(protocol=protocol, config_path=ProjectConfigPath(Path("~/missing.toml")))
+            with typer.Context(TyperCommand("group"), parent=root) as group:
+                with typer.Context(TyperCommand("skill"), parent=group, info_name="skill") as child:
+                    command = CommandContext(child)
+                    assert command.protocol == protocol
+                    assert command.config_input == Path("~/missing.toml")
+                    assert not project_config.is_set()
+        assert not runtime_config.is_set()
+
+    def test_protocol__reads_current_runtime_instead_of_retaining_a_copy(self) -> None:
+        with typer.Context(TyperCommand("show"), info_name="show") as context:
+            context.params["protocol"] = Protocol.automation
+            command = CommandContext(context)
+            observed = [command.protocol]
+            with runtime_config.scope(RuntimeConfig(protocol=Protocol.llm)):
+                observed.append(command.protocol)
+            observed.append(command.protocol)
+            assert observed == [Protocol.automation, Protocol.llm, Protocol.automation]
+
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    @pytest.mark.parametrize("custom_stream", [False, True])
+    def test_init__binds_output_with_selected_protocol_and_supports_stream_override(
+        self, capsys: pytest.CaptureFixture[str], protocol: Protocol, custom_stream: bool
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+        messages = ["Café", "日本語"]
+        stream = io.StringIO()
+
+        with typer.Context(TyperCommand("show"), info_name="show") as context:
+            context.params["protocol"] = protocol
+            CommandContext(context)
+            if custom_stream:
+                context.with_resource(active_output.scope(StreamOutputEmitter(stream=stream)))
+            active_output.get().emit([info(message) for message in messages]).unwrap()
+            assert capsys.readouterr() == ("", "")
+            assert not stream.getvalue()
+            active_output.get().flush()
+
+        captured = capsys.readouterr()
+        output = stream.getvalue() if custom_stream else captured.out
+        assert not (captured.out if custom_stream else stream.getvalue())
+        assert not captured.err
+        if protocol == Protocol.automation:
+            records = [json.loads(line) for line in output.splitlines()]
+            assert [record["content"] for record in records] == messages
+        elif protocol == Protocol.human:
+            assert output == "Café\n\n日本語\n\n"
+        else:
+            assert output.startswith("--TEST-CELL ")
+            assert output.index(messages[0]) < output.index(messages[1])

llm_tool_cli/cli/tests/test_handling.py

@@ -0,0 +1,230 @@
+import io
+import json
+
+import click
+import pytest
+import typer
+from pytest_mock import MockerFixture
+from typer.testing import CliRunner
+
+from llm_tool_cli.cli.errors import InvalidArguments
+from llm_tool_cli.cli.handling import handle_command_errors, report_errors_and_exit
+from llm_tool_cli.config.runtime import RuntimeConfig, runtime_config
+from llm_tool_cli.core.errors import EnvironmentError, EnvironmentErrors, InternalError
+from llm_tool_cli.core.result import Err, Ok, UnwrapError
+from llm_tool_cli.core.settings import ToolLabel, initialize
+from llm_tool_cli.core.tests.fixtures import isolated_settings
+from llm_tool_cli.output import StreamOutputEmitter, output
+from llm_tool_cli.output.errors import JournalCommandFailed
+from llm_tool_cli.protocol import Protocol
+from llm_tool_cli.protocol.logic_cells import ContentCell
+from llm_tool_cli.protocol.logic_cells.journal import JournalCell
+from llm_tool_cli.protocol.logic_cells.warning import WarningCell
+
+__all__ = ["isolated_settings"]
+
+pytestmark = pytest.mark.usefixtures("isolated_settings")
+
+
+class TestReportErrorsAndExit:
+    def test_errors_are_reported_without_journal_processing(self, mocker: MockerFixture) -> None:
+        initialize(label=ToolLabel("TEST"))
+        failures: EnvironmentErrors = [
+            InvalidArguments(reason="first\nsecond"),
+            EnvironmentError(code="unavailable", message="Service unavailable"),
+            JournalCommandFailed(command=["another-tool"], returncode=7, details="failed elsewhere"),
+        ]
+        original = [error.as_record() for error in failures]
+        processor = mocker.Mock()
+        processor.process.side_effect = AssertionError("error reporting must not invoke a journal processor")
+        factory = mocker.Mock(side_effect=AssertionError("error reporting must not invoke a journal factory"))
+        stream = io.StringIO()
+        emitter = StreamOutputEmitter(stream=stream, journal_processor=processor, journal_factory=factory)
+        emitter.emit([ContentCell(kind="success"), WarningCell(message="retained")]).unwrap()
+        with pytest.raises(typer.Exit) as caught:
+            report_errors_and_exit(failures, protocol=Protocol.automation, emitter=emitter)
+        assert caught.value.exit_code == 3
+        processor.process.assert_not_called()
+        factory.assert_not_called()
+        records = [json.loads(line) for line in stream.getvalue().splitlines()]
+        assert [record["code"] for record in records[:3]] == [error.code for error in failures]
+        assert records[0]["content"] == "first\nsecond"
+        assert records[0]["reason"] == "first\nsecond"
+        assert records[3]["message"] == "retained"
+        assert len(records) == 4
+        assert [error.as_record() for error in failures] == original
+
+    @pytest.mark.parametrize("reverse", [False, True])
+    @pytest.mark.parametrize(
+        "delivery_failure",
+        [
+            JournalCommandFailed(command=["tool"], returncode=None, details="unavailable"),
+            EnvironmentError(code="custom_failure", message="unavailable"),
+        ],
+    )
+    def test_failed_emitter_is_not_retried_when_reporting_mixed_errors(
+        self, mocker: MockerFixture, reverse: bool, delivery_failure: EnvironmentError
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+        processor = mocker.Mock()
+        processor.process.return_value = Err([delivery_failure])
+        stream = io.StringIO()
+        emitter = StreamOutputEmitter(stream=stream, journal_processor=processor)
+        failed = emitter.emit([JournalCell(message="failed event")])
+        errors: EnvironmentErrors = [InvalidArguments(reason="original"), *failed.unwrap_err()]
+        if reverse:
+            errors.reverse()
+        with pytest.raises(typer.Exit):
+            report_errors_and_exit(errors, protocol=Protocol.automation, emitter=emitter)
+        assert [json.loads(line)["code"] for line in stream.getvalue().splitlines()] == [
+            error.code for error in errors
+        ]
+        processor.process.assert_called_once()
+
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    @pytest.mark.parametrize("reverse", [False, True])
+    def test_ordered_cells_stream_and_highest_exit_code(  # noqa: CCR001
+        self, capsys: pytest.CaptureFixture[str], protocol: Protocol, reverse: bool
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+        errors: EnvironmentErrors = [
+            InvalidArguments(reason="Invalid café 日本語"),
+            EnvironmentError(code="unavailable", message="Service unavailable"),
+        ]
+        if reverse:
+            errors.reverse()
+        original = [error.as_record() for error in errors]
+
+        with pytest.raises(typer.Exit) as caught:
+            report_errors_and_exit(errors, protocol=protocol)
+
+        assert caught.value.exit_code == 3
+        assert [error.as_record() for error in errors] == original
+        captured = capsys.readouterr()
+        if protocol == Protocol.automation:
+            assert not captured.err
+            records = [json.loads(line) for line in captured.out.splitlines()]
+            for record in records:
+                assert record.pop("id")
+            expected = [{**record, "content": record["message"]} for record in original]
+            for record in expected:
+                del record["message"]
+            assert records == expected
+        else:
+            assert not captured.err
+            separator = ": " if protocol == Protocol.human else "="
+            codes = [f"code{separator}{error.code}\n" for error in errors]
+            assert all(code in captured.out for code in codes)
+            positions = [captured.out.index(code) for code in codes]
+            assert positions == sorted(positions)
+            assert "café 日本語" in captured.out
+            assert "cli_exit_code" not in captured.out
+
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    def test_empty_errors_exit_successfully_without_output(
+        self, capsys: pytest.CaptureFixture[str], protocol: Protocol
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+
+        with pytest.raises(typer.Exit) as caught:
+            report_errors_and_exit([], protocol=protocol)
+
+        assert caught.value.exit_code == 0
+        captured = capsys.readouterr()
+        assert captured.out == captured.err == ""
+
+
+class TestHandleCommandErrors:
+    def test_success_continues_without_output_or_exit(self, capsys: pytest.CaptureFixture[str]) -> None:
+        with handle_command_errors(protocol=Protocol.llm):
+            value = Ok("completed").unwrap()
+
+        assert value == "completed"
+        captured = capsys.readouterr()
+        assert captured.out == captured.err == ""
+
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    def test_failed_command_stops_and_reports_errors(self, protocol: Protocol) -> None:
+        initialize(label=ToolLabel("TEST"))
+        app = typer.Typer()
+
+        @app.command()
+        def fail() -> None:
+            with handle_command_errors(protocol=protocol):
+                Err([InvalidArguments(reason="invalid argument")]).unwrap()
+                typer.echo("unreachable")
+            typer.echo("also unreachable")
+
+        result = CliRunner().invoke(app, [])
+
+        assert result.exit_code == 1
+        assert "unreachable" not in result.output
+        if protocol == Protocol.automation:
+            assert not result.stderr
+            assert json.loads(result.stdout)["code"] == "invalid_arguments"
+        else:
+            assert not result.stderr
+            assert "invalid_arguments" in result.stdout
+
+    @pytest.mark.parametrize(
+        "failure",
+        [RuntimeError("bug"), InternalError("broken state"), typer.Exit(7), click.UsageError("bad usage")],
+    )
+    def test_unrelated_exceptions_propagate_without_output(
+        self, capsys: pytest.CaptureFixture[str], failure: Exception
+    ) -> None:
+        with pytest.raises(type(failure)) as caught:
+            with handle_command_errors(protocol=Protocol.llm):
+                raise failure
+
+        assert caught.value == failure
+        captured = capsys.readouterr()
+        assert captured.out == captured.err == ""
+
+    @pytest.mark.parametrize("payload", [None, "invalid", [InvalidArguments(reason="invalid"), "malformed"]])
+    def test_malformed_unwrap_error_propagates_without_partial_output(
+        self, capsys: pytest.CaptureFixture[str], payload: object
+    ) -> None:
+        failure = UnwrapError(error=[])
+        failure.details["error"] = payload
+
+        with pytest.raises(UnwrapError) as caught:
+            with handle_command_errors(protocol=Protocol.llm):
+                raise failure
+
+        assert caught.value == failure
+        captured = capsys.readouterr()
+        assert captured.out == captured.err == ""
+
+    @pytest.mark.parametrize("protocol", list(Protocol))
+    @pytest.mark.parametrize("custom_stream", [False, True])
+    def test_discard__failure_outputs_error_then_warnings_without_results(
+        self, capsys: pytest.CaptureFixture[str], protocol: Protocol, custom_stream: bool
+    ) -> None:
+        initialize(label=ToolLabel("TEST"))
+        stream = io.StringIO()
+        emitter = StreamOutputEmitter(stream=stream if custom_stream else None)
+        with runtime_config.scope(RuntimeConfig(protocol=protocol)), output.scope(emitter):
+            with pytest.raises(typer.Exit) as caught:
+                with handle_command_errors(protocol=protocol):
+                    emitter.emit([ContentCell(kind="success"), WarningCell(message="keep warning")]).unwrap()
+                    Err([EnvironmentError(code="failed", message="command failed")]).unwrap()
+        assert caught.value.exit_code == 3
+        captured = capsys.readouterr()
+        delivered = stream.getvalue() if custom_stream else captured.out
+        assert not (captured.out if custom_stream else stream.getvalue())
+        assert not captured.err
+        assert "success" not in delivered
+        assert delivered.index("command failed") < delivered.index("keep warning")
+        assert not stream.closed
+        if protocol == Protocol.automation:
+            assert [json.loads(line)["type"] for line in delivered.splitlines()] == ["error", "warning"]
+
+    def test_discard__unexpected_failure_does_not_flush_results(self, capsys: pytest.CaptureFixture[str]) -> None:
+        emitter = StreamOutputEmitter()
+        with output.scope(emitter), pytest.raises(RuntimeError, match="defect"):
+            with handle_command_errors(protocol=Protocol.human):
+                emitter.emit([ContentCell(kind="success")]).unwrap()
+                raise RuntimeError("defect")
+        emitter.flush()
+        assert not capsys.readouterr().out