@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_auto_update_and_migrations.py

@@ -0,0 +1,394 @@
+"""Tests for the auto-update + migrations + supervisor layers.
+
+Covers v0.14.0 new surfaces:
+  * auto_update.check_cached (fresh / stale / network-error semantics)
+  * auto_update.maybe_emit_banner (toggleable, never raises)
+  * auto_update.apply_update (success path, rollback path, no-backup mode)
+  * migrations.discover + run_migrations (sorted, idempotent, journal)
+  * supervisor.find_stalled (heartbeat, deadline, max_iterations)
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine import auto_update as AU         # noqa: E402
+from omega_engine import migrations as MIG         # noqa: E402
+from omega_engine.supervisor import (              # noqa: E402
+    deadman_event, find_stalled,
+)
+from omega_engine.store import SQLiteStore         # noqa: E402
+from omega_engine.events import Event, EventType   # noqa: E402
+from omega_engine.task import Budget               # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Cached check
+# ---------------------------------------------------------------------------
+
+
+class TestCachedCheck(unittest.TestCase):
+    def test_fresh_cache_skips_network(self):
+        """When the cache is younger than interval_s, we MUST NOT hit npm."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            # Pre-seed a fresh cache.
+            cache = AU.CachedCheck(
+                current="0.14.0", latest="0.14.0",
+                is_outdated=False, checked_at=time.time(),
+            )
+            p = AU._cache_path(home)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(cache.to_json())
+
+            # Patch the network call — should NEVER be reached.
+            with mock.patch("omega_engine.updater.check_for_updates") as cf:
+                got = AU.check_cached(home, interval_s=3600)
+                cf.assert_not_called()
+            self.assertEqual(got.current, "0.14.0")
+            self.assertEqual(got.latest, "0.14.0")
+
+    def test_stale_cache_triggers_refresh(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            cache = AU.CachedCheck(
+                current="0.13.0", latest="0.13.0",
+                is_outdated=False, checked_at=time.time() - 999999,
+            )
+            p = AU._cache_path(home)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(cache.to_json())
+
+            from omega_engine.updater import UpdateInfo
+            fake = UpdateInfo(current="0.13.0", latest="0.14.0",
+                              is_outdated=True)
+            with mock.patch("omega_engine.updater.check_for_updates",
+                            return_value=fake) as cf:
+                got = AU.check_cached(home, interval_s=3600)
+                cf.assert_called_once()
+            self.assertEqual(got.latest, "0.14.0")
+            self.assertTrue(got.is_outdated)
+            # The cache file got refreshed.
+            reread = AU.CachedCheck.from_json(p.read_text())
+            self.assertEqual(reread.latest, "0.14.0")
+
+    def test_network_error_does_not_raise(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            from omega_engine.updater import UpdateInfo
+            fake = UpdateInfo(current="0.13.0", latest="?",
+                              is_outdated=False, error="network: down")
+            with mock.patch("omega_engine.updater.check_for_updates",
+                            return_value=fake):
+                got = AU.check_cached(home, force=True)
+            self.assertEqual(got.error, "network: down")
+            self.assertFalse(got.is_outdated)
+
+    def test_corrupt_cache_falls_back_to_refresh(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            p = AU._cache_path(home)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text("{not valid json")
+            from omega_engine.updater import UpdateInfo
+            with mock.patch(
+                "omega_engine.updater.check_for_updates",
+                return_value=UpdateInfo(
+                    current="0.13.0", latest="0.14.0", is_outdated=True),
+            ):
+                got = AU.check_cached(home)
+            self.assertEqual(got.latest, "0.14.0")
+
+
+# ---------------------------------------------------------------------------
+# Banner emission
+# ---------------------------------------------------------------------------
+
+
+class TestBanner(unittest.TestCase):
+    def test_banner_silent_when_up_to_date(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            cache = AU.CachedCheck(
+                current="0.14.0", latest="0.14.0",
+                is_outdated=False, checked_at=time.time(),
+            )
+            AU._cache_path(home).parent.mkdir(parents=True)
+            AU._cache_path(home).write_text(cache.to_json())
+            import io
+            buf = io.StringIO()
+            emitted = AU.maybe_emit_banner(home, stream=buf)
+            self.assertFalse(emitted)
+            self.assertEqual(buf.getvalue(), "")
+
+    def test_banner_emitted_when_outdated(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            cache = AU.CachedCheck(
+                current="0.13.0", latest="0.14.0",
+                is_outdated=True, checked_at=time.time(),
+            )
+            AU._cache_path(home).parent.mkdir(parents=True)
+            AU._cache_path(home).write_text(cache.to_json())
+            import io
+            buf = io.StringIO()
+            emitted = AU.maybe_emit_banner(home, stream=buf)
+            self.assertTrue(emitted)
+            self.assertIn("update available", buf.getvalue())
+            self.assertIn("0.13.0", buf.getvalue())
+            self.assertIn("0.14.0", buf.getvalue())
+
+    def test_opt_out_via_env(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            cache = AU.CachedCheck(
+                current="0.13.0", latest="0.14.0",
+                is_outdated=True, checked_at=time.time(),
+            )
+            AU._cache_path(home).parent.mkdir(parents=True)
+            AU._cache_path(home).write_text(cache.to_json())
+            import io
+            buf = io.StringIO()
+            os.environ["OMEGA_NO_UPDATE_BANNER"] = "1"
+            try:
+                emitted = AU.maybe_emit_banner(home, stream=buf)
+            finally:
+                del os.environ["OMEGA_NO_UPDATE_BANNER"]
+            self.assertFalse(emitted)
+            self.assertEqual(buf.getvalue(), "")
+
+    def test_banner_never_raises_on_io_error(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            # Don't pre-seed; the cache file refresh might hit network
+            with mock.patch("omega_engine.updater.check_for_updates") as cf:
+                from omega_engine.updater import UpdateInfo
+                cf.return_value = UpdateInfo("0.14.0", "0.14.0", False)
+                # Banner with a stream that always raises.
+                class _BadStream:
+                    def write(self, *a, **kw):
+                        raise OSError("disk full")
+                    def flush(self): pass
+                # MUST not raise even though print() under the hood will fail.
+                AU.maybe_emit_banner(home, stream=_BadStream())
+
+
+# ---------------------------------------------------------------------------
+# Apply (success + rollback paths)
+# ---------------------------------------------------------------------------
+
+
+class TestApplyUpdate(unittest.TestCase):
+    def test_up_to_date_short_circuits(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            from omega_engine.updater import UpdateInfo
+            with mock.patch(
+                "omega_engine.updater.check_for_updates",
+                return_value=UpdateInfo("0.14.0", "0.14.0", False),
+            ):
+                res = AU.apply_update(home, skip_backup=True, skip_verify=True)
+            self.assertTrue(res.ok)
+            self.assertIn("up-to-date", res.error)
+
+    def test_network_error_returns_failure_no_rollback(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            from omega_engine.updater import UpdateInfo
+            with mock.patch(
+                "omega_engine.updater.check_for_updates",
+                return_value=UpdateInfo(
+                    "0.13.0", "?", False, error="network: down"),
+            ):
+                res = AU.apply_update(
+                    home, skip_backup=True, skip_verify=True)
+            self.assertFalse(res.ok)
+            self.assertFalse(res.rolled_back)
+            self.assertIn("check failed", res.error)
+
+    def test_journal_records_phases(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            from omega_engine.updater import UpdateInfo
+            # Outdated → mock _run_step to all succeed
+            with mock.patch(
+                "omega_engine.updater.check_for_updates",
+                return_value=UpdateInfo("0.13.0", "0.14.0", True),
+            ):
+                with mock.patch(
+                    "omega_engine.auto_update._run_step",
+                    return_value=(0, "ok"),
+                ):
+                    res = AU.apply_update(
+                        home, skip_backup=True, skip_verify=True,
+                        npm_global=False,
+                    )
+            self.assertTrue(res.ok, res.error)
+            journal = AU._journal_path(home).read_text()
+            self.assertIn("begin", journal)
+            self.assertIn("success", journal)
+
+
+# ---------------------------------------------------------------------------
+# Migrations framework
+# ---------------------------------------------------------------------------
+
+
+class TestMigrations(unittest.TestCase):
+    def test_discover_finds_v0_14_0(self):
+        discovered = MIG.discover()
+        names = [n for _v, n, _f in discovered]
+        self.assertIn("v0_14_0", names)
+
+    def test_discover_is_sorted_ascending(self):
+        discovered = MIG.discover()
+        versions = [v for v, _n, _f in discovered]
+        self.assertEqual(versions, sorted(versions))
+
+    def test_run_migrations_only_runs_in_range(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            # from=0.14.0 to=0.14.0 → empty (we don't re-run the current version)
+            applied = MIG.run_migrations(home, "0.14.0", "0.14.0")
+            self.assertEqual(applied, [])
+
+    def test_run_migrations_applies_v0_14_0(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            applied = MIG.run_migrations(home, "0.13.0", "0.14.0")
+            self.assertEqual(len(applied), 1)
+            self.assertEqual(applied[0]["name"], "v0_14_0")
+            self.assertTrue(applied[0]["ok"])
+            # Migration's anchor file exists
+            anchor = home / "Agentik_Extra" / "var" / "migrations" / ".v0_14_0"
+            self.assertTrue(anchor.exists())
+            # Journal recorded it
+            journal = json.loads(
+                (home / "Agentik_Extra" / "var" / "migrations"
+                 / "_applied.json").read_text()
+            )
+            self.assertEqual(len(journal["applied"]), 1)
+            self.assertEqual(journal["applied"][0]["name"], "v0_14_0")
+
+    def test_run_migrations_idempotent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            applied1 = MIG.run_migrations(home, "0.13.0", "0.14.0")
+            applied2 = MIG.run_migrations(home, "0.13.0", "0.14.0")
+            self.assertEqual(len(applied1), 1)
+            self.assertEqual(applied2, [])  # second call no-ops
+            # Journal still has only the one entry
+            journal = json.loads(
+                (home / "Agentik_Extra" / "var" / "migrations"
+                 / "_applied.json").read_text()
+            )
+            self.assertEqual(len(journal["applied"]), 1)
+
+
+# ---------------------------------------------------------------------------
+# Supervisor — deadman / watchdog
+# ---------------------------------------------------------------------------
+
+
+class TestSupervisorFindStalled(unittest.TestCase):
+    def _make_store(self) -> SQLiteStore:
+        tmp = tempfile.mkdtemp()
+        self.addCleanup(lambda: __import__("shutil").rmtree(tmp,
+                                                             ignore_errors=True))
+        return SQLiteStore(str(Path(tmp) / "ev.db"))
+
+    def test_no_events_no_reports(self):
+        s = self._make_store()
+        self.assertEqual(find_stalled(s, {}), [])
+
+    def _seed_running(self, store: SQLiteStore, task_id: str, ts_start: float):
+        """Drive a task from CREATED → DISPATCHED → RUNNING via the real FSM
+        transitions so the reducer is happy."""
+        store.append(Event(id=f"{task_id}-c", task_id=task_id,
+                           type=EventType.CREATED, ts=ts_start - 2, payload={}))
+        store.append(Event(id=f"{task_id}-d", task_id=task_id,
+                           type=EventType.DISPATCHED, ts=ts_start - 1, payload={}))
+        store.append(Event(id=f"{task_id}-s", task_id=task_id,
+                           type=EventType.STARTED, ts=ts_start, payload={}))
+
+    def test_heartbeat_breach_detected(self):
+        s = self._make_store()
+        now = time.time()
+        # Last event 200s ago, default budget heartbeat=120s → breach.
+        self._seed_running(s, "t-hb", now - 200)
+        reports = find_stalled(s, {}, now=now)
+        self.assertEqual(len(reports), 1)
+        self.assertEqual(reports[0].task_id, "t-hb")
+        self.assertEqual(reports[0].reason, "heartbeat")
+        s.close()
+
+    def test_terminal_task_skipped(self):
+        s = self._make_store()
+        now = time.time()
+        # Walk the FSM all the way to COMPLETED.
+        self._seed_running(s, "t-done", now - 1000)
+        s.append(Event(id="cd", task_id="t-done", type=EventType.CLAIMED_DONE,
+                       ts=now - 998, payload={}))
+        s.append(Event(id="vi", task_id="t-done", type=EventType.VERIFYING,
+                       ts=now - 997, payload={}))
+        s.append(Event(id="vd", task_id="t-done", type=EventType.VERIFIED,
+                       ts=now - 996, payload={}))
+        s.append(Event(id="co", task_id="t-done", type=EventType.COMPLETED,
+                       ts=now - 995, payload={}))
+        # Even though last_ts is 995s ago, task is terminal → no report.
+        reports = find_stalled(s, {}, now=now)
+        self.assertEqual(reports, [])
+        s.close()
+
+    def test_deadline_breach_detected(self):
+        s = self._make_store()
+        now = time.time()
+        self._seed_running(s, "t-dl", now - 10)
+        # heartbeat OK (10s < 120s default) but deadline expired
+        budget = Budget(heartbeat_interval_s=120, deadline_epoch=now - 5)
+        reports = find_stalled(s, {"t-dl": budget}, now=now)
+        self.assertEqual(len(reports), 1)
+        self.assertEqual(reports[0].reason, "deadline")
+        s.close()
+
+    def test_max_iterations_breach_detected(self):
+        s = self._make_store()
+        now = time.time()
+        self._seed_running(s, "t-mi", now - 10)
+        s.append(Event(id="cd", task_id="t-mi", type=EventType.CLAIMED_DONE,
+                       ts=now - 9, payload={}))
+        s.append(Event(id="v1", task_id="t-mi", type=EventType.VERIFYING,
+                       ts=now - 8, payload={}))
+        s.append(Event(id="r1", task_id="t-mi", type=EventType.REJECTED,
+                       ts=now - 7, payload={}))
+        s.append(Event(id="d2", task_id="t-mi", type=EventType.DISPATCHED,
+                       ts=now - 6, payload={}))
+        s.append(Event(id="s2", task_id="t-mi", type=EventType.STARTED,
+                       ts=now - 5, payload={}))
+        budget = Budget(max_iterations=1)  # already exceeded with 1 REJECTED
+        reports = find_stalled(s, {"t-mi": budget}, now=now)
+        self.assertEqual(len(reports), 1)
+        self.assertEqual(reports[0].reason, "max_iterations")
+        s.close()
+
+    def test_deadman_event_shape(self):
+        from omega_engine.supervisor import StallReport
+        ev = deadman_event(StallReport(task_id="t-x", reason="heartbeat"))
+        self.assertEqual(ev.task_id, "t-x")
+        self.assertEqual(ev.type, EventType.FAILED)
+        self.assertIn("deadman", ev.payload["reason"])
+
+
+if __name__ == "__main__":
+    unittest.main()