@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/tests/test_genesis_and_plan.py

@@ -0,0 +1,573 @@
+"""Tests for the Genesis pipeline + Plan v7 FSM-enforced executor.
+
+The two modules are tightly coupled (Genesis writes plan/DAG.json;
+Plan ingests it) — same suite to keep the contract honest.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.genesis import (         # noqa: E402
+    PHASES,
+    GenesisOrchestrator,
+    GenesisState,
+    StackConfig,
+    init_project,
+    load_state,
+    pick_stack,
+    project_root,
+    stack_questions,
+)
+from omega_engine.genesis.state import delete_project  # noqa: E402
+from omega_engine import plan as P                    # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Stack picker
+# ---------------------------------------------------------------------------
+
+
+class TestStackPicker(unittest.TestCase):
+    def test_default_is_omegaos_canonical(self):
+        cfg = pick_stack(accept_defaults=True)
+        self.assertEqual(cfg.type, "web")
+        self.assertEqual(cfg.frontend, "nextjs")
+        self.assertEqual(cfg.backend, "convex")
+        self.assertEqual(cfg.deploy, "vercel")
+        self.assertEqual(cfg.payments, "stripe")
+        self.assertEqual(cfg.ui_kit, "shadcn")
+        self.assertEqual(cfg.auth, "clerk")
+
+    def test_questions_cover_five_essentials(self):
+        keys = {q.key for q in stack_questions()}
+        self.assertEqual(
+            keys, {"type", "backend", "frontend", "auth", "payments"}
+        )
+
+    def test_iphone_forces_swiftui_and_none_deploy(self):
+        cfg = pick_stack(answers={"type": "iphone"})
+        self.assertEqual(cfg.mobile, "swiftui")
+        self.assertEqual(cfg.deploy, "none")
+        self.assertEqual(cfg.ui_kit, "custom")
+
+    def test_mobile_expo_couples_eas(self):
+        cfg = pick_stack(answers={"type": "mobile", "frontend": "expo"})
+        self.assertEqual(cfg.mobile, "expo")
+        self.assertEqual(cfg.deploy, "eas")
+
+    def test_supabase_couples_auth(self):
+        cfg = pick_stack(answers={"backend": "supabase"})
+        self.assertEqual(cfg.auth, "supabase-auth")
+
+    def test_supabase_with_explicit_auth_keeps_it(self):
+        cfg = pick_stack(answers={"backend": "supabase", "auth": "clerk"})
+        self.assertEqual(cfg.auth, "clerk")
+
+    def test_library_strips_payments_and_deploy(self):
+        cfg = pick_stack(answers={"type": "library"})
+        self.assertEqual(cfg.deploy, "none")
+        self.assertEqual(cfg.payments, "none")
+        self.assertEqual(cfg.ui_kit, "tailwind-only")
+
+    def test_rejects_unknown_key(self):
+        with self.assertRaises(ValueError):
+            pick_stack(answers={"not_a_key": "bogus"})
+
+    def test_rejects_invalid_value(self):
+        with self.assertRaises(ValueError):
+            pick_stack(answers={"backend": "neo4j"})
+
+
+# ---------------------------------------------------------------------------
+# State machine (PROJECT.yaml)
+# ---------------------------------------------------------------------------
+
+
+class TestState(unittest.TestCase):
+    def test_init_creates_canonical_tree(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            state = init_project("acme", omega_home=home)
+            root = project_root("acme", omega_home=home)
+            self.assertTrue((root / "PROJECT.yaml").exists())
+            for sub in ("docs/10-market", "docs/20-brand",
+                        "docs/30-prd", "docs/40-features", "plan"):
+                self.assertTrue((root / sub).is_dir(), sub)
+            self.assertEqual(state.phase, "stack")
+            self.assertEqual(state.completed_phases, [])
+
+    def test_init_refuses_duplicate_without_force(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            with self.assertRaises(FileExistsError):
+                init_project("acme", omega_home=home)
+
+    def test_init_force_overwrites(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", name="First", omega_home=home)
+            init_project("acme", name="Second", force=True, omega_home=home)
+            self.assertEqual(load_state("acme", omega_home=home).name,
+                             "Second")
+
+    def test_load_state_round_trip(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", intent="X", omega_home=home)
+            state = load_state("acme", omega_home=home)
+            self.assertEqual(state.intent, "X")
+            self.assertEqual(state.slug, "acme")
+
+    def test_invalid_slug_rejected(self):
+        with self.assertRaises(ValueError):
+            project_root("../etc/passwd")
+        with self.assertRaises(ValueError):
+            project_root("with spaces")
+
+    def test_mark_phase_done_advances_pointer(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            state = load_state("acme", omega_home=home)
+            state.mark_phase_done("stack")
+            self.assertIn("stack", state.completed_phases)
+            self.assertEqual(state.phase, "vision")
+
+    def test_next_phase_walks_through_all(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            state = load_state("acme", omega_home=home)
+            order: list[str] = []
+            while True:
+                nxt = state.next_phase()
+                if nxt is None:
+                    break
+                order.append(nxt)
+                state.mark_phase_done(nxt)
+            self.assertEqual(tuple(order), PHASES)
+
+
+class TestDeleteProject(unittest.TestCase):
+    def test_delete_returns_true_when_present(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            self.assertTrue(delete_project("acme", omega_home=home))
+            self.assertFalse(project_root("acme", omega_home=home).exists())
+
+    def test_delete_returns_false_when_absent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            self.assertFalse(delete_project("nope", omega_home=home))
+
+
+# ---------------------------------------------------------------------------
+# Orchestrator — walks every phase, writes files, flips state
+# ---------------------------------------------------------------------------
+
+
+class TestOrchestrator(unittest.TestCase):
+    def test_run_all_walks_every_phase(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", intent="A test SaaS", omega_home=home)
+            orch = GenesisOrchestrator("acme", omega_home=home)
+            results = orch.run_all()
+            phases_run = [r.phase for r in results]
+            self.assertEqual(tuple(phases_run), PHASES)
+            for r in results:
+                self.assertTrue(r.ok, f"{r.phase} failed: {r.error}")
+
+    def test_files_land_in_correct_subdirs(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            GenesisOrchestrator("acme", omega_home=home).run_all()
+            root = project_root("acme", omega_home=home)
+            # Vision: one file at the top of docs/
+            self.assertTrue((root / "docs" / "00-VISION.md").exists())
+            # Market: 5 files
+            market = list((root / "docs" / "10-market").glob("*.md"))
+            self.assertEqual(len(market), 5)
+            # Branding: 3 files
+            brand = list((root / "docs" / "20-brand").glob("*.md"))
+            self.assertEqual(len(brand), 3)
+            # PRD: 9 files
+            prd = list((root / "docs" / "30-prd").glob("*.md"))
+            self.assertEqual(len(prd), 9)
+            # Features: at least 6 starter + TEMPLATE
+            features = sorted((root / "docs" / "40-features").glob("*.md"))
+            self.assertGreaterEqual(len(features), 7)
+            # DAG.json is valid JSON with the right shape
+            dag = json.loads((root / "plan" / "DAG.json").read_text())
+            self.assertIn("features", dag)
+            self.assertGreaterEqual(len(dag["features"]), 6)
+            self.assertEqual(dag["slug"], "acme")
+
+    def test_resume_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            orch = GenesisOrchestrator("acme", omega_home=home)
+            # Run halfway
+            r1 = orch.run()
+            self.assertEqual(r1.phase, "stack")
+            r2 = orch.run()
+            self.assertEqual(r2.phase, "vision")
+            # Status reflects that
+            st = orch.status()
+            self.assertIn("vision", st["completed_phases"])
+            # Resume — picks up at market
+            r3 = orch.run()
+            self.assertEqual(r3.phase, "market")
+
+    def test_only_runs_specific_phase(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            orch = GenesisOrchestrator("acme", omega_home=home)
+            # Force PRD phase even though we haven't done vision
+            r = orch.run(only="prd")
+            self.assertEqual(r.phase, "prd")
+            self.assertTrue(r.ok)
+
+    def test_status_reports_remaining(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("acme", omega_home=home)
+            orch = GenesisOrchestrator("acme", omega_home=home)
+            orch.run()                      # stack
+            orch.run()                      # vision
+            st = orch.status()
+            self.assertEqual(st["phase"], "market")
+            self.assertIn("market", st["remaining_phases"])
+
+    def test_per_project_isolation(self):
+        """Genesis on slug-a writes nothing under slug-b's tree."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("alpha", omega_home=home)
+            init_project("beta", omega_home=home)
+            GenesisOrchestrator("alpha", omega_home=home).run_all()
+            beta_root = project_root("beta", omega_home=home)
+            # Beta should still be empty except for the init skeleton
+            self.assertFalse((beta_root / "docs" / "00-VISION.md").exists())
+            self.assertFalse((beta_root / "plan" / "DAG.json").exists())
+
+
+# ---------------------------------------------------------------------------
+# Plan v7 — FSM enforcement (the bug fix)
+# ---------------------------------------------------------------------------
+
+
+def _bootstrap_plan(home: Path, slug: str = "demo") -> None:
+    """Helper: init + run genesis + build the plan store."""
+    init_project(slug, omega_home=home)
+    GenesisOrchestrator(slug, omega_home=home).run_all()
+    P.build_plan(slug, omega_home=home)
+
+
+class TestPlanBuild(unittest.TestCase):
+    def test_build_inserts_features_from_dag(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            res = P.build_plan("demo", omega_home=home)
+            # idempotent: second call updates, not re-inserts
+            self.assertEqual(res["inserted"], 0)
+            self.assertGreaterEqual(res["updated"], 6)
+            self.assertGreaterEqual(res["total"], 6)
+
+    def test_build_validates_dag(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("demo", omega_home=home)
+            GenesisOrchestrator("demo", omega_home=home).run_all()
+            # Corrupt the DAG: feature pointing at unknown dep
+            dag_p = project_root("demo", omega_home=home) / "plan" / "DAG.json"
+            dag = json.loads(dag_p.read_text())
+            dag["features"].append({
+                "id": "F-999", "title": "bad",
+                "depends_on": ["F-XYZ"], "wave": 1,
+                "estimated_minutes": 10, "files_owned": [],
+                "verify_cmd": "true", "skill": "",
+            })
+            dag_p.write_text(json.dumps(dag))
+            with self.assertRaises(P.PlanError):
+                P.build_plan("demo", omega_home=home)
+
+    def test_build_detects_cycle(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            init_project("demo", omega_home=home)
+            GenesisOrchestrator("demo", omega_home=home).run_all()
+            dag_p = project_root("demo", omega_home=home) / "plan" / "DAG.json"
+            dag_p.write_text(json.dumps({
+                "slug": "demo",
+                "features": [
+                    {"id": "A", "title": "a", "depends_on": ["B"], "wave": 1,
+                     "estimated_minutes": 1, "files_owned": [],
+                     "verify_cmd": "true", "skill": ""},
+                    {"id": "B", "title": "b", "depends_on": ["A"], "wave": 1,
+                     "estimated_minutes": 1, "files_owned": [],
+                     "verify_cmd": "true", "skill": ""},
+                ],
+            }))
+            with self.assertRaises(P.PlanError):
+                P.build_plan("demo", omega_home=home)
+
+
+class TestPlanFSM(unittest.TestCase):
+    """The core bug-fix proofs — every adversarial path is rejected."""
+
+    def test_next_eligible_is_root_task(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            t = P.next_eligible("demo", omega_home=home)
+            self.assertEqual(t.id, "F-001")          # the root
+            self.assertEqual(t.depends_on, [])
+
+    def test_cannot_jump_past_dependencies(self):
+        """The original v6 bug: agent skipping T-050 to T-090.
+        Here: F-006 depends on F-001 + F-003. Must reject."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            with self.assertRaises(P.PlanError) as ctx:
+                P.mark_in_progress("demo", "F-006", omega_home=home)
+            self.assertIn("unverified deps", str(ctx.exception))
+
+    def test_cannot_skip_state_pending_to_verified(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            with self.assertRaises(P.PlanError):
+                P.mark_done("demo", "F-001", omega_home=home, verify=False)
+
+    def test_cannot_skip_in_progress_to_verified(self):
+        """Even after in_progress, must go through claimed_done."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            P.mark_in_progress("demo", "F-001", omega_home=home)
+            # Direct in_progress → verified is illegal
+            # mark_done auto-bridges via claimed_done when verify=False,
+            # but the underlying _transition would reject it. Use the
+            # explicit funnel:
+            from omega_engine.plan import _transition, VERIFIED
+            with self.assertRaises(P.PlanError):
+                _transition("demo", "F-001", VERIFIED, omega_home=home)
+
+    def test_normal_flow_advances(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            P.mark_in_progress("demo", "F-001", omega_home=home)
+            P.mark_claimed_done("demo", "F-001", omega_home=home)
+            t = P.mark_done("demo", "F-001", verify=False, omega_home=home)
+            self.assertEqual(t.state, P.VERIFIED)
+
+    def test_completed_dep_unlocks_next(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            # Walk F-001 to VERIFIED
+            P.mark_in_progress("demo", "F-001", omega_home=home)
+            P.mark_claimed_done("demo", "F-001", omega_home=home)
+            P.mark_done("demo", "F-001", verify=False, omega_home=home)
+            # Now F-002 (deps F-001) should be eligible
+            t = P.next_eligible("demo", omega_home=home)
+            self.assertEqual(t.id, "F-002")
+            # F-006 still blocked (also needs F-003)
+            with self.assertRaises(P.PlanError):
+                P.mark_in_progress("demo", "F-006", omega_home=home)
+
+    def test_verify_failure_routes_to_failed(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            P.mark_in_progress("demo", "F-001", omega_home=home)
+            P.mark_claimed_done("demo", "F-001", omega_home=home)
+            # Override the verify_cmd to a guaranteed failure
+            import sqlite3
+            with sqlite3.connect(str(P.db_path("demo", omega_home=home))) as conn:
+                conn.execute(
+                    "UPDATE tasks SET verify_cmd=? WHERE slug=? AND id=?",
+                    ("exit 1", "demo", "F-001"),
+                )
+                conn.commit()
+            t = P.mark_done("demo", "F-001", verify=True, omega_home=home)
+            self.assertEqual(t.state, P.FAILED)
+            self.assertIn("rc=", t.last_error)
+            # And the failed task does NOT unlock F-002
+            t2 = P.next_eligible("demo", omega_home=home)
+            # F-002 needs F-001 verified — should NOT be eligible.
+            # next_eligible returns None or a different non-dependent task.
+            # In our seed F-001 has no dependent at wave 1 other than F-002,
+            # F-003. F-004 depends on F-002 → blocked too. So nothing
+            # eligible.
+            self.assertIsNone(t2)
+
+    def test_retry_resets_failed_to_pending(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            P.mark_in_progress("demo", "F-001", omega_home=home)
+            P.mark_failed("demo", "F-001", reason="explicit",
+                          omega_home=home)
+            t = P.retry("demo", "F-001", omega_home=home)
+            self.assertEqual(t.state, P.PENDING)
+            self.assertEqual(t.last_error, "")
+
+    def test_status_reports_completion(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            # Verify F-001
+            P.mark_in_progress("demo", "F-001", omega_home=home)
+            P.mark_claimed_done("demo", "F-001", omega_home=home)
+            P.mark_done("demo", "F-001", verify=False, omega_home=home)
+            st = P.status("demo", omega_home=home)
+            self.assertEqual(st["counts"]["verified"], 1)
+            self.assertGreater(st["completion_pct"], 0)
+            self.assertLess(st["completion_pct"], 100)
+
+    def test_list_filters_by_state(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            pending = P.list_tasks("demo", state=P.PENDING, omega_home=home)
+            self.assertEqual(len(pending), 6)
+            self.assertEqual(P.list_tasks("demo", state=P.VERIFIED,
+                                          omega_home=home), [])
+
+
+class TestPlanRun(unittest.TestCase):
+    """The multi-day autonomous loop — the closing piece for the user's
+    'agents qui travaillent plusieurs jours' requirement."""
+
+    def test_run_dry_mode_walks_root_only_when_verify_passes(self):
+        """With no dispatch + no spawn, verify_cmd runs as-is. Only tasks
+        whose verify_cmd exits 0 advance."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            # Override every task's verify_cmd to `true` so they all pass
+            import sqlite3
+            conn = sqlite3.connect(str(P.db_path("demo", omega_home=home)))
+            conn.execute("UPDATE tasks SET verify_cmd='true' WHERE slug='demo'")
+            conn.commit(); conn.close()
+            # No dispatch → loop just walks the FSM
+            result = P.run("demo", omega_home=home, max_iterations=10)
+            self.assertEqual(result.iterations, 6)        # 6 starter features
+            self.assertEqual(len(result.verified), 6)
+            self.assertEqual(len(result.failed), 0)
+            st = P.status("demo", omega_home=home)
+            self.assertEqual(st["completion_pct"], 100.0)
+
+    def test_run_respects_dependency_chain(self):
+        """Force the verify_cmd of F-003 (auth-flow) to fail. Dependants
+        (F-005 dashboard-shell, F-006 billing) must NOT be touched."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            import sqlite3
+            conn = sqlite3.connect(str(P.db_path("demo", omega_home=home)))
+            conn.execute("UPDATE tasks SET verify_cmd='true' WHERE slug='demo'")
+            conn.execute(
+                "UPDATE tasks SET verify_cmd='exit 1' "
+                "WHERE slug='demo' AND id='F-003'"
+            )
+            conn.commit(); conn.close()
+            result = P.run("demo", omega_home=home, max_iterations=10)
+            # F-003 fails → blocks F-005 + F-006
+            self.assertIn("F-003", result.failed)
+            tasks = {t.id: t for t in P.list_tasks("demo", omega_home=home)}
+            self.assertEqual(tasks["F-003"].state, P.FAILED)
+            self.assertEqual(tasks["F-005"].state, P.PENDING)  # NEVER touched
+            self.assertEqual(tasks["F-006"].state, P.PENDING)  # NEVER touched
+            # Independent branches (F-001, F-002, F-004) still verify
+            self.assertEqual(tasks["F-001"].state, P.VERIFIED)
+            self.assertEqual(tasks["F-002"].state, P.VERIFIED)
+            self.assertEqual(tasks["F-004"].state, P.VERIFIED)
+
+    def test_run_max_iterations_caps_loop(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            import sqlite3
+            conn = sqlite3.connect(str(P.db_path("demo", omega_home=home)))
+            conn.execute("UPDATE tasks SET verify_cmd='true' WHERE slug='demo'")
+            conn.commit(); conn.close()
+            result = P.run("demo", omega_home=home, max_iterations=2)
+            self.assertEqual(result.iterations, 2)
+            self.assertEqual(len(result.verified), 2)
+
+    def test_run_dispatch_callback_invoked_per_task(self):
+        """The custom dispatch callable replaces the spawn_cmd path."""
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            import sqlite3
+            conn = sqlite3.connect(str(P.db_path("demo", omega_home=home)))
+            conn.execute("UPDATE tasks SET verify_cmd='true' WHERE slug='demo'")
+            conn.commit(); conn.close()
+            dispatched: list[str] = []
+            def fake_dispatch(task):
+                dispatched.append(task.id)
+            P.run("demo", omega_home=home, max_iterations=3,
+                  dispatch=fake_dispatch)
+            self.assertEqual(dispatched, ["F-001", "F-002", "F-003"])
+
+    def test_run_on_iteration_hook_fires(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home)
+            import sqlite3
+            conn = sqlite3.connect(str(P.db_path("demo", omega_home=home)))
+            conn.execute("UPDATE tasks SET verify_cmd='true' WHERE slug='demo'")
+            conn.commit(); conn.close()
+            events: list[tuple[str, str]] = []
+            P.run("demo", omega_home=home, max_iterations=2,
+                  on_iteration=lambda t, r: events.append((t.id, r)))
+            self.assertEqual(len(events), 2)
+            self.assertEqual(events[0][1], "verified")
+
+
+class TestPlanIsolation(unittest.TestCase):
+    """Two projects must not share state or DB."""
+
+    def test_two_projects_each_have_own_db(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp)
+            _bootstrap_plan(home, "alpha")
+            _bootstrap_plan(home, "beta")
+            # Advance alpha only
+            P.mark_in_progress("alpha", "F-001", omega_home=home)
+            P.mark_claimed_done("alpha", "F-001", omega_home=home)
+            P.mark_done("alpha", "F-001", verify=False, omega_home=home)
+            # Beta untouched
+            st_b = P.status("beta", omega_home=home)
+            self.assertEqual(st_b["counts"]["verified"], 0)
+            self.assertEqual(st_b["counts"]["pending"], 6)
+            # And the file paths are different
+            self.assertNotEqual(
+                str(P.db_path("alpha", omega_home=home)),
+                str(P.db_path("beta", omega_home=home)),
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()