Run events in the database: Runs page and Agent run card on the Dokploy Portal

Snapshot of D:\Ecw Process 65c92c5 (2026-10-30).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/test_run_events_db.py

@@ -0,0 +1,129 @@
+r"""
+core/run_events.py — every event also goes to `dbo.CV_RunEvent` (operator,
+2026-10-30): the Portal on Dokploy cannot read the bot PC's Logs folder, so
+its Runs page showed "No runs match" for every date.
+
+The file stays the record of a Run; the database row is a copy. A database
+that is off, missing the table or down never stops a Run — after the first
+failure the copy is switched off for the rest of the Run, said once in the
+log.
+
+    python tests\test_run_events_db.py
+
+No database: the writer is a stand-in.
+"""
+
+import io
+import sys
+import json
+import pathlib
+import tempfile
+import contextlib
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent / "src"))
+
+from ecw_bot import settings as cfg                   # noqa: E402
+from ecw_bot.core import run_events                   # noqa: E402
+
+CASES = []
+
+
+def case(fn):
+    CASES.append(fn)
+    return fn
+
+
+def _start(tmp, writer):
+    run_events._db_writer = writer
+    log = pathlib.Path(tmp) / "run_20261030_101500.log"
+    run_events.start(log, "VERIFY")
+    return log
+
+
+@case
+def every_event_is_copied_with_its_run_id_and_kind(tmp):
+    rows = []
+    _start(tmp, lambda run_id, at, kind, body: rows.append(
+        (run_id, kind, json.loads(body))))
+    run_events.emit("claim_start", n=1, total=2, claim="9103000")
+    run_events.close()
+    assert [k for _, k, _ in rows] == ["run_start", "claim_start"], rows
+    assert {r for r, _, _ in rows} == {"20261030_101500"}
+    assert rows[1][2]["claim"] == "9103000" and rows[1][2]["t"], rows
+
+
+@case
+def the_file_and_the_row_carry_the_same_line(tmp):
+    bodies = []
+    log = _start(tmp, lambda run_id, at, kind, body: bodies.append(body))
+    run_events.emit("warning", code="x", message="y")
+    run_events.close()
+    lines = run_events.path_for(log).read_text(encoding="utf-8").splitlines()
+    assert lines == bodies, (lines, bodies)
+
+
+@case
+def a_database_error_switches_the_copy_off_and_the_run_goes_on(tmp):
+    calls = []
+
+    def boom(*a):
+        calls.append(a)
+        raise OSError("no such table")
+    out = io.StringIO()
+    with contextlib.redirect_stdout(out):
+        log = _start(tmp, boom)
+        run_events.emit("claim_start", n=1)
+        run_events.emit("claim_start", n=2)
+        run_events.close()
+    assert len(calls) == 1, "tried once, then off"
+    assert out.getvalue().count("[EVENTS]") == 1, out.getvalue()
+    assert len(run_events.path_for(log).read_text().splitlines()) == 3
+
+
+@case
+def an_event_added_after_a_stop_is_copied_too(tmp):
+    rows = []
+    run_events._db_writer = lambda run_id, at, kind, body: rows.append(kind)
+    log = pathlib.Path(tmp) / "run_20261030_101500.log"
+    run_events.append_to(log, "stopped", by="sam")
+    assert rows == ["stopped"], rows
+
+
+@case
+def a_run_outside_the_logs_folder_is_never_copied(tmp):
+    rows = []
+    run_events._db_writer = lambda *a: rows.append(a)
+    other = pathlib.Path(tmp) / "elsewhere"
+    other.mkdir()
+    run_events.start(other / "run_20261030_101500.log", "VERIFY")
+    run_events.emit("claim_start", n=1)
+    run_events.close()
+    run_events.append_to(other / "run_20261030_101500.log", "stopped")
+    assert rows == [], "a test's run never reaches the database"
+
+
+def main() -> int:
+    failures = 0
+    real = run_events._db_writer
+    for fn in CASES:
+        name = fn.__name__.replace("_", " ")
+        with tempfile.TemporaryDirectory() as tmp:
+            cfg.LOGS = pathlib.Path(tmp)     # a real-looking Logs folder
+            try:
+                fn(tmp)
+                print(f"  ok    {name}")
+            except AssertionError as exc:
+                print(f"  FAIL  {name}: {exc}")
+                failures += 1
+            except Exception as exc:
+                print(f"  ERROR {name}: {type(exc).__name__}: {exc}")
+                failures += 1
+            finally:
+                run_events._reset()
+                run_events._db_writer = real
+    print(f"\n{len(CASES) - failures}/{len(CASES)} passed")
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())