loghunter-cli 0.1.0.dev0__py3-none-any.whl

tests/test_display.py

@@ -0,0 +1,370 @@
+"""Tests for the liveness primitive in loghunter.common.display."""
+
+from __future__ import annotations
+
+import sys
+import threading
+import time
+
+import pytest
+
+from loghunter.common import display as display_mod
+from loghunter.common.display import (
+    _SPINNER_FRAMES,
+    _color_enabled,
+    _stream_isatty,
+    liveness,
+    progress,
+)
+
+
+class _FakeStream:
+    """Minimal stderr stand-in for liveness tests.
+
+    Exposes ``isatty()``, ``write()``, ``flush()`` and an ``output``
+    property that joins the captured chunks. Writes are guarded by a lock
+    so the spinner thread and the test body do not tear a string.
+    """
+
+    def __init__(self, tty: bool) -> None:
+        self._tty = tty
+        self._chunks: list[str] = []
+        self._lock = threading.Lock()
+
+    def isatty(self) -> bool:
+        return self._tty
+
+    def write(self, s: str) -> int:
+        with self._lock:
+            self._chunks.append(s)
+        return len(s)
+
+    def flush(self) -> None:  # pragma: no cover - no-op
+        return None
+
+    @property
+    def output(self) -> str:
+        with self._lock:
+            return "".join(self._chunks)
+
+
+def _has_any_frame(text: str) -> bool:
+    return any(f in text for f in _SPINNER_FRAMES)
+
+
+def _poll_until_drew(stream: _FakeStream, budget_s: float = 0.5) -> bool:
+    """Poll the fake's buffer until a \\r appears, signalling _drew flipped."""
+    deadline = time.monotonic() + budget_s
+    while time.monotonic() < deadline:
+        if "\r" in stream.output:
+            return True
+        time.sleep(0.005)
+    return False
+
+
+# ── Test 1 ──────────────────────────────────────────────────────────────────
+
+
+def test_non_tty_silent_enter_seal_writes_record_only(monkeypatch):
+    fake = _FakeStream(tty=False)
+    monkeypatch.setattr(sys, "stderr", fake)
+    with liveness("running thing") as ln:
+        ln.seal("done")
+    assert fake.output == "done\n"
+
+
+# ── Test 2 ──────────────────────────────────────────────────────────────────
+
+
+def test_non_tty_exception_writes_nothing(monkeypatch):
+    fake = _FakeStream(tty=False)
+    monkeypatch.setattr(sys, "stderr", fake)
+    with pytest.raises(RuntimeError):
+        with liveness("running thing"):
+            raise RuntimeError("boom")
+    assert fake.output == ""
+
+
+# ── Test 3 — the byte-exact one ─────────────────────────────────────────────
+
+
+def test_seal_before_delay_is_byte_exact(monkeypatch):
+    fake = _FakeStream(tty=True)
+    monkeypatch.setattr(sys, "stderr", fake)
+    # delay=10s means the spinner thread is parked in stop_event.wait(10);
+    # immediate seal sets the event before any frame can draw.
+    with liveness("running thing", delay=10.0) as ln:
+        ln.seal("done")
+    # Exact buffer: only the record line. No \r, no spaces, no frame chars.
+    assert fake.output == "done\n"
+
+
+# ── Test 4 ──────────────────────────────────────────────────────────────────
+
+
+def test_exception_after_drew_clears_no_record(monkeypatch):
+    fake = _FakeStream(tty=True)
+    monkeypatch.setattr(sys, "stderr", fake)
+    with pytest.raises(RuntimeError):
+        with liveness("running thing", delay=0.0):
+            assert _poll_until_drew(fake), (
+                "spinner thread did not draw within budget — _drew=True "
+                "branch not exercised"
+            )
+            raise RuntimeError("boom")
+    # Spinner drew, so _drew was True, so teardown emitted a clearing \r.
+    assert "\r" in fake.output
+    # And nothing claiming success was written.
+    assert "done" not in fake.output
+    # __exit__ never writes a newline-terminated record on its own —
+    # only the spinner's own \r-redrawn line should be in the buffer.
+    assert "\n" not in fake.output
+
+
+# ── Test 5 ──────────────────────────────────────────────────────────────────
+
+
+def test_keyboard_interrupt_propagates(monkeypatch):
+    fake = _FakeStream(tty=True)
+    monkeypatch.setattr(sys, "stderr", fake)
+    with pytest.raises(KeyboardInterrupt):
+        with liveness("running thing", delay=0.0):
+            # No need to wait for a frame here — the contract is that
+            # KeyboardInterrupt (a BaseException, not an Exception) is
+            # not swallowed by the context manager.
+            raise KeyboardInterrupt
+    # No false seal.
+    assert "done" not in fake.output
+
+
+# ── Test 6 ──────────────────────────────────────────────────────────────────
+
+
+def test_seal_is_idempotent(monkeypatch):
+    fake = _FakeStream(tty=False)
+    monkeypatch.setattr(sys, "stderr", fake)
+    with liveness("running thing") as ln:
+        ln.seal("done")
+        ln.seal("done")
+    assert fake.output == "done\n"
+
+
+# ── Bonus: a spinner that actually drew, then sealed, clears once ──────────
+
+
+def test_seal_after_drew_clears_then_writes_record(monkeypatch):
+    fake = _FakeStream(tty=True)
+    monkeypatch.setattr(sys, "stderr", fake)
+    with liveness("running thing", delay=0.0) as ln:
+        assert _poll_until_drew(fake), (
+            "spinner thread did not draw within budget"
+        )
+        ln.seal("done")
+    out = fake.output
+    # Spinner drew at least one frame char.
+    assert _has_any_frame(out)
+    # Sealed record is present and is the LAST thing in the buffer.
+    assert out.endswith("done\n")
+    # Exactly one record line.
+    assert out.count("done\n") == 1
+
+
+# ── progress() helper ───────────────────────────────────────────────────────
+
+
+class _TqdmSpy:
+    """Spy that records construction kwargs and acts as the tqdm bar object.
+
+    Patched in for `loghunter.common.display.tqdm` so progress() tests can
+    assert that tqdm IS or IS NOT constructed, inspect the kwargs the helper
+    passes when it is, and observe the counter (`progress()` now drives the bar
+    via `update(1)` from its own generator — NO iterable is passed to tqdm).
+    """
+
+    def __init__(self) -> None:
+        self.calls: list[dict] = []
+        self.n = 0
+        self.closed = False
+
+    def __call__(self, iterable=None, **kwargs):
+        self.calls.append(kwargs)
+        return self
+
+    def __iter__(self):
+        # progress() must drive the bar via update(1) from its OWN generator and
+        # never iterate the tqdm object directly. If a regression returns the bar
+        # itself (the `loaded X: 0.00 lines` orphaned-counter bug), fail LOUDLY
+        # here rather than with a confusing AttributeError downstream.
+        raise AssertionError(
+            "progress() iterated the tqdm bar directly — it must wrap it in its "
+            "own counting generator (iter(gen) is gen) so the count survives "
+            "parser re-iteration"
+        )
+
+    def update(self, k: int = 1) -> None:
+        self.n += k
+
+    def close(self) -> None:
+        self.closed = True
+
+
+def test_progress_disabled_returns_bare_iterable_no_tqdm(monkeypatch):
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    fake = _FakeStream(tty=True)
+    items = [1, 2, 3]
+    result = list(progress(items, desc="loaded x.log",
+                           show_progress=False, stream=fake))
+    assert result == [1, 2, 3]
+    assert spy.calls == []  # tqdm NEVER constructed when disabled
+
+
+def test_progress_non_tty_returns_bare_iterable_no_tqdm(monkeypatch):
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    fake = _FakeStream(tty=False)
+    items = ["a", "b"]
+    result = list(progress(items, desc="loaded x.log",
+                           show_progress=True, stream=fake))
+    assert result == ["a", "b"]
+    assert spy.calls == []  # tqdm NEVER constructed off a TTY
+
+
+def test_progress_tty_constructs_tqdm_with_pinned_format(monkeypatch):
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    fake = _FakeStream(tty=True)
+    # The return is now a GENERATOR wrapping the tqdm; tqdm is constructed WITHOUT
+    # an iterable and driven via update(1).
+    out = list(progress(["a"], desc="loaded x.log",
+                        show_progress=True, unit=" lines", stream=fake))
+    assert out == ["a"]
+    assert len(spy.calls) == 1
+    kw = spy.calls[0]
+    # Pinned bar_format reproduces the long-standing NDJSON bar byte-for-byte
+    # when unit=" lines".
+    assert kw["bar_format"] == "{desc}: {n_fmt} lines [{elapsed}]"
+    assert kw["desc"] == "loaded x.log"
+    assert kw["unit"] == " lines"
+    assert kw["leave"] is True
+    assert kw["unit_scale"] is True
+    assert kw["mininterval"] == 0.5
+    assert kw["file"] is fake
+    # The generator drove the bar and closed it.
+    assert spy.n == 1
+    assert spy.closed is True
+
+
+def test_progress_count_survives_two_phase_reiteration(monkeypatch):
+    """Regression for `loaded X: 0.00 lines`: a parser that sniffs-then-resumes
+    (Zeek `itertools.chain(prefix, line_iter)`) re-iterates the progress result.
+    Because progress() returns a GENERATOR (iter(gen) is gen), the SAME counter
+    continues — every item is counted exactly once. Exercises the REAL progress()
+    (only `tqdm` is faked for inspection; progress itself is NOT replaced)."""
+    import itertools
+
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    fake = _FakeStream(tty=True)
+    items = list(range(10))
+
+    it = progress(items, desc="loaded conn.log",
+                  show_progress=True, unit=" lines", stream=fake)
+    # Phase 1: sniff one item then break (mimics the NDJSON-vs-TSV sniff).
+    prefix: list[int] = []
+    for x in it:
+        prefix.append(x)
+        break
+    # Phase 2: chain the prefix back and consume the rest from the SAME iterator.
+    rest = list(itertools.chain(prefix, it))
+
+    assert rest == items, "every item observed once, in order, across re-iteration"
+    assert spy.n == 10, "counter is the TRUE total, not orphaned at the sniff break"
+    assert spy.closed is True
+
+
+def test_progress_unit_parameterization(monkeypatch):
+    """Different units (e.g. " events") thread cleanly into bar_format."""
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    fake = _FakeStream(tty=True)
+    list(progress(["a"], desc="loaded x", show_progress=True,
+                  unit=" events", stream=fake))
+    assert spy.calls[0]["bar_format"] == "{desc}: {n_fmt} events [{elapsed}]"
+
+
+def test_progress_ignores_no_color(monkeypatch):
+    """Color policy is NOT a progress policy — a color preference must not
+    suppress the progress bar."""
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    monkeypatch.setenv("NO_COLOR", "1")
+    fake = _FakeStream(tty=True)
+    list(progress(["a"], desc="loaded x", show_progress=True, stream=fake))
+    assert len(spy.calls) == 1
+
+
+def test_progress_ignores_term_dumb(monkeypatch):
+    """TERM=dumb is a color signal, not a progress signal."""
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    monkeypatch.setenv("TERM", "dumb")
+    fake = _FakeStream(tty=True)
+    list(progress(["a"], desc="loaded x", show_progress=True, stream=fake))
+    assert len(spy.calls) == 1
+
+
+def test_progress_defaults_to_sys_stderr(monkeypatch):
+    """When stream= is not passed, the helper resolves it to sys.stderr."""
+    spy = _TqdmSpy()
+    monkeypatch.setattr(display_mod, "tqdm", spy)
+    fake = _FakeStream(tty=True)
+    monkeypatch.setattr(sys, "stderr", fake)
+    list(progress(["a"], desc="loaded x", show_progress=True))
+    assert len(spy.calls) == 1
+    assert spy.calls[0]["file"] is fake
+
+
+# ── _stream_isatty factoring regression ─────────────────────────────────────
+
+
+def test_stream_isatty_handles_missing_attr():
+    """An object without isatty() resolves to False (no crash)."""
+
+    class _Bare:
+        pass
+
+    assert _stream_isatty(_Bare()) is False
+
+
+def test_stream_isatty_handles_raising_isatty():
+    """isatty() raising is treated as False (no propagation)."""
+
+    class _Boom:
+        def isatty(self):
+            raise OSError("nope")
+
+    assert _stream_isatty(_Boom()) is False
+
+
+def test_stream_isatty_true_and_false():
+    assert _stream_isatty(_FakeStream(tty=True)) is True
+    assert _stream_isatty(_FakeStream(tty=False)) is False
+
+
+def test_color_enabled_still_layers_no_color_and_term_dumb(monkeypatch):
+    """Color policy keeps NO_COLOR / TERM=dumb ON TOP of the raw TTY probe."""
+    fake_tty = _FakeStream(tty=True)
+    fake_non_tty = _FakeStream(tty=False)
+
+    monkeypatch.delenv("NO_COLOR", raising=False)
+    monkeypatch.delenv("TERM", raising=False)
+    assert _color_enabled(fake_tty) is True
+    assert _color_enabled(fake_non_tty) is False
+
+    monkeypatch.setenv("NO_COLOR", "1")
+    assert _color_enabled(fake_tty) is False
+
+    monkeypatch.delenv("NO_COLOR")
+    monkeypatch.setenv("TERM", "dumb")
+    assert _color_enabled(fake_tty) is False