test: add coverage for interspersed options and command groups

Author: zigai

tests/argparse/layout/test_help_rendering_regressions.py

@@ -411,6 +411,24 @@ def mul(self) -> None:
     assert "{add,mul}" in help_text
 
 
+def test_standard_layout_class_root_help_renders_one_commands_section() -> None:
+    class Calculator:
+        def add(self, a: float, b: float) -> float:
+            return a + b
+
+        def mul(self, a: float, b: float) -> float:
+            return a * b
+
+    parser = Argparser(help_layout=StandardLayout(), sys_exit_enabled=False, print_result=False)
+    parser.add_command(Calculator)
+
+    help_text = parser.build_parser().format_help()
+
+    assert len(re.findall(r"^commands:$", help_text, re.MULTILINE)) == 1
+    assert len(re.findall(r"^\s+add(?:\s|$)", help_text, re.MULTILINE)) == 1
+    assert len(re.findall(r"^\s+mul(?:\s|$)", help_text, re.MULTILINE)) == 1
+
+
 def test_interfacy_layout_usage_subcommand_choices_exclude_aliases() -> None:
     ops = CommandGroup("ops")
     ops.add_command(lambda: None, name="cache_prune", aliases=("prune",))

tests/argparse/test_types/test_primitives.py

@@ -12,6 +12,25 @@
 
 
 class TestPrimitives:
+    @pytest.mark.parametrize("parser", ["argparse_req_pos"], indirect=True)
+    def test_bad_int_error_uses_user_facing_type_name(
+        self, parser: InterfacyParser, capsys: pytest.CaptureFixture[str]
+    ):
+        """Invalid typed values should show argparse-style type names."""
+
+        def greet(name: str, times: int = 1) -> str:
+            return name * times
+
+        parser.add_command(greet)
+
+        with pytest.raises(SystemExit) as excinfo:
+            parser.parse_args(["Ada", "--times", "bad"])
+
+        assert excinfo.value.code == 2
+        captured = capsys.readouterr()
+        assert "argument -t/--times: invalid int value: 'bad'" in captured.err
+        assert "parser[int]" not in captured.err
+
     @pytest.mark.parametrize("parser", ["argparse_req_pos", "argparse_kw_only"], indirect=True)
     def test_str_required(self, parser: InterfacyParser):
         """Verify that a required string argument is correctly parsed from positional or flag input."""

tests/click/test_click_parity.py

@@ -173,6 +173,7 @@ def test_interfacy_click_group_help_position_aligns_command_rows() -> None:
             help="Disable the per-job duration limit.",
         )
     )
+
     group.interfacy_help_position = 42
     group.interfacy_help_position_explicit = True
 

tests/common/test_command_group.py

@@ -1,3 +1,5 @@
+import sys
+
 import pytest
 
 from interfacy import CommandGroup
@@ -197,6 +199,22 @@ def test_single_group_with_one_function(self, parser: InterfacyParser):
         parser.add_command(cli)
         assert parser.run(args=["cli", "greet", "Ada"]) == "Hello, Ada!"
 
+    @pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
+    def test_group_function_command_accepts_pipe_targets(
+        self,
+        parser: InterfacyParser,
+        mocker,
+        monkeypatch: pytest.MonkeyPatch,
+    ):
+        """Grouped function commands can receive stdin through per-command pipe config."""
+        cli = CommandGroup("cli")
+        cli.add_command(greet, pipe_targets="name")
+        parser.add_command(cli)
+        monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+        mocker.patch("interfacy.core.read_piped", return_value="Ada")
+
+        assert parser.run(args=["cli", "greet"]) == "Hello, Ada!"
+
     @pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
     def test_single_group_with_multiple_functions(self, parser: InterfacyParser):
         """Verify single group with multiple functions works."""
@@ -259,6 +277,30 @@ def test_class_init_args_become_group_flags(self, parser: InterfacyParser):
         result = parser.run(args=["workspace", "container", "--format", "json", "run", "nginx"])
         assert result == "Running nginx with format json"
 
+    @pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
+    def test_class_pipe_targets_apply_to_initializer(
+        self,
+        parser: InterfacyParser,
+        mocker,
+        monkeypatch: pytest.MonkeyPatch,
+    ):
+        """Grouped class pipe targets can satisfy initializer parameters."""
+
+        class PrefixTool:
+            def __init__(self, prefix: str) -> None:
+                self.prefix = prefix
+
+            def run(self, value: str = "x") -> str:
+                return f"{self.prefix}{value}"
+
+        workspace = CommandGroup("workspace")
+        workspace.add_command(PrefixTool, name="tool", pipe_targets="prefix")
+        parser.add_command(workspace)
+        monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+        mocker.patch("interfacy.core.read_piped", return_value="pre-")
+
+        assert parser.run(args=["workspace", "tool", "run"]) == "pre-x"
+
     @pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
     def test_class_multiple_methods(self, parser: InterfacyParser):
         """Verify multiple class methods are accessible."""

tests/common/test_help_command_groups.py

@@ -3,7 +3,7 @@
 import pytest
 
 from interfacy import CommandGroup
-from interfacy.appearance.layouts import ArgparseLayout
+from interfacy.appearance.layouts import ArgparseLayout, StandardLayout
 from interfacy.argparse_backend import Argparser
 from interfacy.exceptions import ConfigurationError
 
@@ -24,6 +24,14 @@ def cmd_init() -> None:
     """Initialize a repository."""
 
 
+def cmd_push() -> None:
+    """Push changes."""
+
+
+def cmd_pull() -> None:
+    """Pull changes."""
+
+
 @pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
 def test_root_help_groups_commands_before_ungrouped(parser, capsys) -> None:
     parser.add_command(cmd_status, name="status")
@@ -53,6 +61,48 @@ def test_root_help_groups_commands_before_ungrouped(parser, capsys) -> None:
     assert init_idx < status_idx
 
 
+@pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
+def test_help_group_command_indent_is_configurable(parser, capsys) -> None:
+    parser.apply_setup(help_layout=StandardLayout(command_indent=5))
+    parser.add_command(cmd_clone, name="clone", help_group="setup")
+    parser.add_command(cmd_status, name="status")
+
+    result = parser.run(args=["--help"])
+    assert isinstance(result, SystemExit)
+    assert result.code == 0
+
+    captured = capsys.readouterr()
+    combined = _strip_ansi(captured.out + captured.err)
+    lines = combined.splitlines()
+
+    assert any(line.startswith("     clone") for line in lines)
+
+
+@pytest.mark.parametrize("parser", ["argparse_req_pos", "click_req_pos"], indirect=True)
+def test_help_group_spacing_is_configurable(parser, capsys) -> None:
+    parser.apply_setup(help_layout=StandardLayout(command_group_spacing=0))
+    parser.add_command(cmd_clone, name="clone", help_group="setup")
+    parser.add_command(cmd_push, name="push", help_group="sync")
+    parser.add_command(cmd_pull, name="pull")
+
+    result = parser.run(args=["--help"])
+    assert isinstance(result, SystemExit)
+    assert result.code == 0
+
+    captured = capsys.readouterr()
+    combined = _strip_ansi(captured.out + captured.err)
+    lines = combined.splitlines()
+    clone_idx = next(idx for idx, line in enumerate(lines) if line.strip().startswith("clone"))
+    sync_idx = lines.index("sync")
+    push_idx = next(idx for idx, line in enumerate(lines) if line.strip().startswith("push"))
+    pull_idx = next(idx for idx, line in enumerate(lines) if line.strip().startswith("pull"))
+
+    assert lines[clone_idx + 1] == "sync"
+    assert lines[push_idx + 1].lstrip().startswith("pull")
+    assert sync_idx == clone_idx + 1
+    assert pull_idx == push_idx + 1
+
+
 @pytest.mark.parametrize("backend", ["argparse", "click"])
 def test_nested_help_groups_render_with_adaptive_layout(backend: str, capsys) -> None:
     if backend == "click":

tests/common/test_interrupt.py

@@ -12,6 +12,7 @@ def slow_task(seconds: int = 10) -> str:
     """A slow task that can be interrupted."""
     for _ in range(seconds):
         time.sleep(0.1)
+
     return "Done"