Add tests of folded table printer

Unit tests of the Row class and some higher level integration tests of
the printer itself to ensure it produces proper tabular output both
with and without folding enabled.

Author: sirosen

src/globus_cli/commands/endpoint/search.py

@@ -158,7 +158,6 @@ def endpoint_search(
         search_iterator,
         fields=ENDPOINT_LIST_FIELDS,
         json_converter=iterable_response_to_dict,
-        text_mode=display.FOLDED_TABLE,
     )
 
     if search_iterator.has_next():

src/globus_cli/commands/group/list.py

@@ -22,5 +22,4 @@ def group_list(login_manager: LoginManager) -> None:
             SESSION_ENFORCEMENT_FIELD,
             Field("Roles", "my_memberships[].role", formatter=formatters.SortedArray),
         ],
-        text_mode=display.FOLDED_TABLE,
     )

src/globus_cli/termio/printers/folded_table_printer.py

@@ -42,9 +42,10 @@ class FoldedTablePrinter(Printer[t.Iterable[t.Any]]):
     :param fields: a list of Fields with load and render instructions; one per column.
     """
 
-    def __init__(self, fields: t.Iterable[Field]) -> None:
+    def __init__(self, fields: t.Iterable[Field], width: int | None = None) -> None:
         self._fields = tuple(fields)
-        self._width = _get_terminal_content_width()
+        self._width = width or _get_terminal_content_width()
+        self._folding_enabled = _detect_folding_enabled()
 
     def echo(self, data: t.Iterable[t.Any], stream: t.IO[str] | None = None) -> None:
         """
@@ -83,7 +84,7 @@ def echo(self, data: t.Iterable[t.Any], stream: t.IO[str] | None = None) -> None
             echo(_separator_line(col_widths, style=table_style | OutputStyle.bottom))
 
     def _fold_table(self, table: RowTable) -> RowTable:
-        if not _detect_folding_enabled():
+        if not self._folding_enabled:
             return table
 
         # if the table is initially narrow enough to fit, do not fold
@@ -208,7 +209,7 @@ def fold(self, n: int) -> Row:
 
     def _split_level(
         self, level: tuple[str, ...], modulus: int
-    ) -> t.Iterator[tuple[str, ...], ...]:
+    ) -> t.Iterator[tuple[str, ...]]:
         bins = collections.defaultdict(list)
         for i, x in enumerate(level):
             bins[i % modulus].append(x)

tests/unit/termio/printer/test_folded_table_printer.py

@@ -0,0 +1,191 @@
+from io import StringIO
+
+import pytest
+
+from globus_cli.termio import Field
+from globus_cli.termio.printers import FoldedTablePrinter
+from globus_cli.termio.printers.folded_table_printer import Row
+
+
+@pytest.mark.parametrize(
+    "folding_enabled, width",
+    (
+        (False, 10),
+        (False, 1000),
+        (True, 1000),
+    ),
+)
+def test_folded_table_printer_can_print_unfolded_output(folding_enabled, width):
+    fields = (
+        Field("Column A", "a"),
+        Field("Column B", "b"),
+        Field("Column C", "c"),
+    )
+    data = (
+        {"a": 1, "b": 4, "c": 7},
+        {"a": 2, "b": 5, "c": 8},
+        {"a": 3, "b": 6, "c": 9},
+    )
+    printer = FoldedTablePrinter(fields=fields, width=width)
+    # override detection, set by test
+    printer._folding_enabled = folding_enabled
+
+    with StringIO() as stream:
+        printer.echo(data, stream)
+        printed_table = stream.getvalue()
+
+    # fmt: off
+    assert printed_table == (
+        "Column A | Column B | Column C\n"
+        "---------+----------+---------\n"
+        "1        | 4        | 7       \n"
+        "2        | 5        | 8       \n"
+        "3        | 6        | 9       \n"
+    )
+    # fmt: on
+
+
+def test_folded_table_printer_can_fold_in_half():
+    fields = (
+        Field("Column A", "a"),
+        Field("Column B", "b"),
+        Field("Column C", "c"),
+        Field("Column D", "d"),
+    )
+    data = (
+        {"a": 1, "b": 4, "c": 7, "d": "alpha"},
+        {"a": 2, "b": 5, "c": 8, "d": "beta"},
+        {"a": 3, "b": 6, "c": 9, "d": "gamma"},
+    )
+
+    printer = FoldedTablePrinter(fields=fields, width=25)
+    # override detection of an interactive session
+    printer._folding_enabled = True
+
+    with StringIO() as stream:
+        printer.echo(data, stream)
+        printed_table = stream.getvalue()
+
+    # fmt: off
+    assert printed_table == (
+        ".----------+----------.\n"
+        "| Column A | Column C |\n"
+        "| Column B | Column D |\n"
+        "+==========+==========+\n"
+        "| 1        | 7        |\n"
+        "| 4        | alpha    |\n"
+        "+----------+----------+\n"
+        "| 2        | 8        |\n"
+        "| 5        | beta     |\n"
+        "+----------+----------+\n"
+        "| 3        | 9        |\n"
+        "| 6        | gamma    |\n"
+        "'----------+----------'\n"
+    )
+    # fmt: on
+
+
+def test_folded_table_printer_can_fold_in_half_unevenly():
+    fields = (
+        Field("Column A", "a"),
+        Field("Column B", "b"),
+        Field("Column C", "c"),
+    )
+    data = (
+        {"a": 1, "b": 4, "c": 7, "d": "alpha"},
+        {"a": 2, "b": 5, "c": 8, "d": "beta"},
+        {"a": 3, "b": 6, "c": 9, "d": "gamma"},
+    )
+
+    printer = FoldedTablePrinter(fields=fields, width=25)
+    # override detection of an interactive session
+    printer._folding_enabled = True
+
+    with StringIO() as stream:
+        printer.echo(data, stream)
+        printed_table = stream.getvalue()
+
+    # fmt: off
+    assert printed_table == (
+        ".----------+----------.\n"
+        "| Column A | Column C |\n"
+        "| Column B |          |\n"
+        "+==========+==========+\n"
+        "| 1        | 7        |\n"
+        "| 4        |          |\n"
+        "+----------+----------+\n"
+        "| 2        | 8        |\n"
+        "| 5        |          |\n"
+        "+----------+----------+\n"
+        "| 3        | 9        |\n"
+        "| 6        |          |\n"
+        "'----------+----------'\n"
+    )
+    # fmt: on
+
+
+def test_row_folding_no_remainder():
+    six_items = Row((("1", "2", "3", "4", "5", "6"),))
+
+    # fold by 2 or "in half"
+    fold2 = six_items.fold(2)
+    assert len(fold2.grid) == 2
+    assert fold2.grid == (
+        ("1", "3", "5"),  # odds
+        ("2", "4", "6"),  # evens
+    )
+
+    # fold by 3 or "in thirds"
+    fold3 = six_items.fold(3)
+    assert len(fold3.grid) == 3
+    assert fold3.grid == (
+        ("1", "4"),
+        ("2", "5"),
+        ("3", "6"),
+    )
+
+    # fold by N where N is the number of columns
+    fold6 = six_items.fold(6)
+    assert len(fold6.grid) == 6
+    assert fold6.grid == (
+        ("1",),
+        ("2",),
+        ("3",),
+        ("4",),
+        ("5",),
+        ("6",),
+    )
+
+
+def test_row_folding_with_remainder():
+    five_items = Row(
+        (
+            (
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+            ),
+        )
+    )
+
+    # fold by 2 or "in half"
+    fold2 = five_items.fold(2)
+    assert len(fold2.grid) == 2
+    assert fold2.grid == (
+        ("1", "3", "5"),  # odds
+        (
+            "2",
+            "4",
+        ),  # evens
+    )
+
+    # fold by 3 or "in thirds"
+    fold3 = five_items.fold(3)
+    assert len(fold3.grid) == 3
+    assert fold3.grid == (
+        ("1", "4"),
+        ("2", "5"),
+        ("3",),
+    )