dsh-biocore 0.2.0 → 0.3.1

package/python/biocore_model/tests/test_rerank.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+"""Rerank core tests: config, protocols, sorting, truncation, silent fallback."""
+import json
+import unittest
+
+from biocore_runtime import rerank
+
+
+class FakeTransport:
+    def __init__(self, responses):
+        self.responses = list(responses)
+        self.calls = []
+
+    def __call__(self, url, payload, timeout, headers):
+        self.calls.append({"url": url, "payload": payload,
+                           "timeout": timeout, "headers": dict(headers)})
+        response = self.responses.pop(0)
+        if isinstance(response, Exception):
+            raise response
+        return response
+
+
+def ok(results):
+    return (200, json.dumps({"results": results}).encode("utf-8"))
+
+
+def cfg(**overrides):
+    data = {
+        "rerank_enabled": True,
+        "rerank_base_url": "https://api.example.com",
+        "rerank_model": "bge-reranker",
+    }
+    data.update(overrides)
+    return data
+
+
+class ConfigTest(unittest.TestCase):
+    def test_defaults(self):
+        data = rerank.normalize_config({})
+        self.assertFalse(data["rerank_enabled"])
+        self.assertEqual(data["rerank_base_url"], "")
+        self.assertEqual(data["rerank_model"], "")
+        self.assertEqual(data["rerank_api_key"], "")
+        self.assertEqual(data["rerank_timeout"], 8.0)
+        self.assertEqual(data["rerank_top_n"], 20)
+
+    def test_clamps_timeout_and_top_n(self):
+        data = rerank.normalize_config(cfg(rerank_timeout=999, rerank_top_n=0))
+        self.assertEqual(data["rerank_timeout"], 60.0)
+        self.assertEqual(data["rerank_top_n"], 1)
+        data = rerank.normalize_config(cfg(rerank_timeout=-1, rerank_top_n=9999))
+        self.assertEqual(data["rerank_timeout"], 0.1)
+        self.assertEqual(data["rerank_top_n"], 1000)
+
+
+class DegradeTest(unittest.TestCase):
+    def test_disabled_never_calls_transport(self):
+        transport = FakeTransport([AssertionError("should not call")])
+        reasons = []
+        out = rerank.rerank_documents(
+            "q", ["a", "b"], {"rerank_enabled": False},
+            transport=transport, on_reason=reasons.append)
+        self.assertIsNone(out)
+        self.assertEqual(transport.calls, [])
+        self.assertEqual(reasons, ["disabled"])
+
+    def test_missing_config_degrades(self):
+        transport = FakeTransport([AssertionError("should not call")])
+        reasons = []
+        out = rerank.rerank_documents(
+            "q", ["a"], {"rerank_enabled": True, "rerank_model": "m"},
+            transport=transport, on_reason=reasons.append)
+        self.assertIsNone(out)
+        self.assertEqual(transport.calls, [])
+        self.assertEqual(reasons, ["missing_config"])
+
+    def test_non_2xx_degrades(self):
+        transport = FakeTransport([(500, b"oops"), (503, b"nope")])
+        reasons = []
+        out = rerank.rerank_documents("q", ["a", "b"], cfg(),
+                                      transport=transport,
+                                      on_reason=reasons.append)
+        self.assertIsNone(out)
+        self.assertEqual(len(transport.calls), 2)
+        self.assertEqual(reasons, ["http_503"])
+
+    def test_timeout_degrades_one_attempt(self):
+        transport = FakeTransport([TimeoutError("slow")])
+        reasons = []
+        out = rerank.rerank_documents("q", ["a"], cfg(),
+                                      transport=transport,
+                                      on_reason=reasons.append)
+        self.assertIsNone(out)
+        self.assertEqual(len(transport.calls), 1)
+        self.assertEqual(reasons, ["timeout"])
+
+    def test_bad_json_degrades(self):
+        transport = FakeTransport([(200, b"not json"), (200, b"not json")])
+        reasons = []
+        out = rerank.rerank_documents("q", ["a"], cfg(),
+                                      transport=transport,
+                                      on_reason=reasons.append)
+        self.assertIsNone(out)
+        self.assertEqual(reasons, ["bad_json"])
+
+
+class ProtocolTest(unittest.TestCase):
+    def test_rerank_endpoint_first_and_payload(self):
+        transport = FakeTransport([ok([{"index": 0, "relevance_score": 0.3}])])
+        out = rerank.rerank_documents("query", ["doc-a", "doc-b"], cfg(),
+                                      transport=transport)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(transport.calls[0]["url"],
+                         "https://api.example.com/rerank")
+        payload = transport.calls[0]["payload"]
+        self.assertEqual(payload["model"], "bge-reranker")
+        self.assertEqual(payload["query"], "query")
+        self.assertEqual(payload["documents"], ["doc-a", "doc-b"])
+        self.assertEqual(payload["top_n"], 2)
+        self.assertEqual(transport.calls[0]["timeout"], 8.0)
+
+    def test_v1_rerank_fallback(self):
+        transport = FakeTransport([(404, b"no"), ok([{"index": 1, "relevance_score": 0.9}])])
+        out = rerank.rerank_documents("q", ["a", "b"], cfg(),
+                                      transport=transport)
+        self.assertIsNotNone(out)
+        self.assertEqual([call["url"] for call in transport.calls], [
+            "https://api.example.com/rerank",
+            "https://api.example.com/v1/rerank",
+        ])
+        self.assertEqual(out[0]["index"], 1)
+
+    def test_v1_base_does_not_double_v1(self):
+        transport = FakeTransport([ok([{"index": 0, "relevance_score": 0.5}])])
+        rerank.rerank_documents("q", ["a"], cfg(
+            rerank_base_url="https://api.example.com/v1"),
+            transport=transport)
+        self.assertEqual(transport.calls[0]["url"],
+                         "https://api.example.com/v1/rerank")
+
+    def test_auth_header_and_timeout_forwarded(self):
+        transport = FakeTransport([ok([{"index": 0, "relevance_score": 0.5}])])
+        rerank.rerank_documents("q", ["a"], cfg(
+            rerank_api_key="secret", rerank_timeout=3.5),
+            transport=transport)
+        call = transport.calls[0]
+        self.assertEqual(call["headers"].get("Authorization"),
+                         "Bearer secret")
+        self.assertEqual(call["timeout"], 3.5)
+
+
+class RankingTest(unittest.TestCase):
+    def test_sorted_by_relevance(self):
+        transport = FakeTransport([ok([
+            {"index": 0, "relevance_score": 0.2},
+            {"index": 1, "relevance_score": 0.9},
+            {"index": 2, "relevance_score": 0.5},
+        ])])
+        out = rerank.rerank_documents("q", ["a", "b", "c"], cfg(),
+                                      transport=transport)
+        self.assertEqual([row["index"] for row in out], [1, 2, 0])
+        self.assertEqual([row["document"] for row in out], ["b", "c", "a"])
+
+    def test_top_n_truncates(self):
+        transport = FakeTransport([ok([
+            {"index": index, "relevance_score": index / 10.0}
+            for index in range(5)
+        ])])
+        out = rerank.rerank_documents("q", ["a", "b", "c", "d", "e"],
+                                      cfg(rerank_top_n=2),
+                                      transport=transport)
+        self.assertEqual(len(out), 2)
+        self.assertEqual([row["index"] for row in out], [4, 3])
+        self.assertEqual(transport.calls[0]["payload"]["top_n"], 2)
+
+    def test_invalid_results_skipped(self):
+        transport = FakeTransport([ok([
+            {"index": 0, "relevance_score": 0.4},
+            {"index": 99, "relevance_score": 0.9},
+            {"index": 1, "relevance_score": "bad"},
+            "garbage",
+        ])])
+        out = rerank.rerank_documents("q", ["a", "b"], cfg(),
+                                      transport=transport)
+        self.assertEqual([row["index"] for row in out], [0])
+
+    def test_ties_keep_index_order(self):
+        transport = FakeTransport([ok([
+            {"index": 2, "relevance_score": 0.5},
+            {"index": 0, "relevance_score": 0.5},
+            {"index": 1, "relevance_score": 0.5},
+        ])])
+        out = rerank.rerank_documents("q", ["a", "b", "c"], cfg(),
+                                      transport=transport)
+        self.assertEqual([row["index"] for row in out], [0, 1, 2])
+
+
+class PipelineHookTest(unittest.TestCase):
+    def test_tool_recall_uses_rerank_hook(self):
+        import tempfile
+        from unittest.mock import patch
+        from biocore_runtime import pipeline as pl
+        root = tempfile.mkdtemp(prefix="biocore-rerank-hook-")
+        pl.tool_call("remember", {"text": "第一条记忆"}, root, session_id="s")
+        pl.tool_call("remember", {"text": "第二条记忆"}, root, session_id="s")
+        fake = lambda query, docs, config=None, **kwargs: [
+            {"index": 0, "document": docs[0], "relevance_score": 0.9},
+            {"index": 1, "document": docs[1], "relevance_score": 0.1},
+        ]
+        with patch.object(pl._rerank_mod, "rerank_documents", fake):
+            out = pl.tool_call("recall", {
+                "query": "记忆", "limit": 2,
+                "rerank_config": {"rerank_enabled": True},
+            }, root, session_id="s")
+        self.assertEqual([row["text"] for row in out["results"]],
+                         ["第二条记忆", "第一条记忆"])
+
+    def test_recall_action_falls_back_without_config(self):
+        from biocore_runtime import pipeline
+        out = pipeline.dispatch("recall", {
+            "query": "q", "documents": ["a", "b"],
+            "config": {"rerank_enabled": False}})
+        self.assertTrue(out["ok"])
+        self.assertFalse(out["reranked"])
+        self.assertEqual([row["index"] for row in out["results"]], [0, 1])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_rollback.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+"""task-126: rollback snapshot/restore + bounded ring tests."""
+import unittest
+from pathlib import Path
+
+from biocore_model import rollback
+
+REPO = Path(__file__).resolve().parents[2]
+
+
+def _doc():
+    return {
+        "state": {"v": 0.2, "a": 0.6, "d": 0.5, "social": 0.4,
+                  "stress": 0.3, "energy": 0.7, "trust": 0.55,
+                  "echo": 0.1, "echo_trace": 0.1, "attention": 0.5,
+                  "boredom": 0.1, "novelty_need": 0.4,
+                  "boundary_pressure": 0.0, "refusal_readiness": 0.0,
+                  "conflict_ema": 0.0, "rumination_ema": 0.0, "ticks": 7,
+                  "unknown": 99, "label": "x", "flag": True},
+        "needs": {"belonging": 0.6, "self_esteem": 0.5, "control": 0.4,
+                  "meaningful_existence": 0.55, "other": 0.1},
+        "relationship": {"trust": 0.55, "state": {"closeness": 0.6},
+                         "repair_state": {"phase": "stable"}},
+        "recent_turns": [{"role": "user", "text": "a"},
+                         {"role": "assistant", "text": "b"}],
+        "memory_marker": {"entries": ["id1"], "turn": {"count": 1}},
+    }
+
+
+class SnapshotTest(unittest.TestCase):
+    def test_state_whitelist_only(self):
+        snap = rollback.snapshot(_doc())
+        self.assertNotIn("unknown", snap["state"])
+        self.assertNotIn("label", snap["state"])
+        self.assertNotIn("flag", snap["state"])
+        self.assertEqual(snap["state"]["v"], 0.2)
+        self.assertIn("ticks", snap["state"])
+
+    def test_needs_whitelist(self):
+        snap = rollback.snapshot(_doc())
+        self.assertNotIn("other", snap["needs"])
+        self.assertEqual(snap["needs"]["belonging"], 0.6)
+
+    def test_relationship_and_recent_copied(self):
+        doc = _doc()
+        snap = rollback.snapshot(doc)
+        self.assertEqual(snap["relationship"]["trust"], 0.55)
+        self.assertEqual(len(snap["recent_turns"]), 2)
+        self.assertEqual(snap["memory_marker"]["entries"], ["id1"])
+        doc["relationship"]["trust"] = 0.9
+        doc["recent_turns"].append({"role": "user", "text": "c"})
+        self.assertEqual(snap["relationship"]["trust"], 0.55)
+        self.assertEqual(len(snap["recent_turns"]), 2)
+
+    def test_recent_turns_bounded(self):
+        doc = _doc()
+        doc["recent_turns"] = [{"role": "user", "text": str(i)}
+                               for i in range(20)]
+        snap = rollback.snapshot(doc)
+        self.assertEqual(len(snap["recent_turns"]), rollback.RECENT_LIMIT)
+        self.assertEqual(snap["recent_turns"][-1]["text"], "19")
+        snap2 = rollback.snapshot(doc, recent_limit=3)
+        self.assertEqual(len(snap2["recent_turns"]), 3)
+
+    def test_empty_and_none_are_safe(self):
+        for value in (None, {}, [], "x"):
+            snap = rollback.snapshot(value)
+            self.assertIsInstance(snap, dict)
+            self.assertEqual(snap["state"], {})
+            self.assertEqual(snap["recent_turns"], [])
+
+
+class RestoreTest(unittest.TestCase):
+    def test_restore_applies_all_fields(self):
+        snap = rollback.snapshot(_doc())
+        target = {"state": {"v": -0.5, "stress": 0.9}, "needs": {},
+                  "relationship": {}, "recent_turns": []}
+        out = rollback.restore(target, snap)
+        self.assertAlmostEqual(out["state"]["v"], 0.2)
+        self.assertAlmostEqual(out["state"]["stress"], 0.3)
+        self.assertEqual(out["needs"]["control"], 0.4)
+        self.assertEqual(len(out["recent_turns"]), 2)
+        self.assertEqual(out["memory_marker"]["entries"], ["id1"])
+
+    def test_restore_empty_snapshot_keeps_doc(self):
+        target = _doc()
+        out = rollback.restore(target, {})
+        self.assertEqual(out["state"]["v"], 0.2)
+        out2 = rollback.restore(target, None)
+        self.assertEqual(out2["state"]["stress"], 0.3)
+
+    def test_restore_malformed_snapshot_is_safe(self):
+        target = {"state": {"v": 0.1}}
+        for snap in ([], "x", {"state": "nope"}, {"needs": 5}):
+            out = rollback.restore(target, snap)
+            self.assertEqual(out["state"]["v"], 0.1)
+
+    def test_restore_does_not_mutate_inputs(self):
+        doc = _doc()
+        snap = rollback.snapshot(doc)
+        before_doc = repr(doc)
+        before_snap = repr(snap)
+        rollback.restore(doc, snap)
+        self.assertEqual(repr(doc), before_doc)
+        self.assertEqual(repr(snap), before_snap)
+
+    def test_roundtrip(self):
+        doc = _doc()
+        snap = rollback.snapshot(doc)
+        doc["state"]["v"] = -0.9
+        doc["recent_turns"] = []
+        doc["relationship"]["trust"] = 0.1
+        restored = rollback.restore(doc, snap)
+        self.assertAlmostEqual(restored["state"]["v"], 0.2)
+        self.assertEqual(len(restored["recent_turns"]), 2)
+        self.assertEqual(restored["relationship"]["trust"], 0.55)
+
+
+class RingTest(unittest.TestCase):
+    def _snap(self, value):
+        return {"state": {"v": value}}
+
+    def test_push_bounded_to_limit(self):
+        ring = []
+        for index in range(15):
+            ring = rollback.push(ring, self._snap(index / 10.0))
+        self.assertEqual(len(ring), rollback.RING_LIMIT)
+        self.assertAlmostEqual(ring[-1]["state"]["v"], 1.4)
+        self.assertAlmostEqual(ring[0]["state"]["v"], 0.5)
+
+    def test_push_copies_snapshot(self):
+        snap = self._snap(0.3)
+        ring = rollback.push([], snap)
+        snap["state"]["v"] = -1.0
+        self.assertAlmostEqual(ring[0]["state"]["v"], 0.3)
+
+    def test_pop_newest_first(self):
+        ring = rollback.push(rollback.push([], self._snap(0.1)),
+                             self._snap(0.2))
+        left, latest = rollback.pop(ring)
+        self.assertAlmostEqual(latest["state"]["v"], 0.2)
+        self.assertEqual(len(left), 1)
+
+    def test_pop_empty(self):
+        self.assertEqual(rollback.pop([]), ([], None))
+        self.assertEqual(rollback.pop(None), ([], None))
+
+    def test_consecutive_two_rollbacks(self):
+        ring = []
+        for value in (0.1, 0.2, 0.3):
+            ring = rollback.push(ring, self._snap(value))
+        ring, first = rollback.pop(ring)
+        ring, second = rollback.pop(ring)
+        self.assertAlmostEqual(first["state"]["v"], 0.3)
+        self.assertAlmostEqual(second["state"]["v"], 0.2)
+        self.assertEqual(len(ring), 1)
+
+    def test_can_rollback_and_describe(self):
+        self.assertFalse(rollback.can_rollback([]))
+        self.assertTrue(rollback.can_rollback([{"state": {}}]))
+        snap = rollback.snapshot(_doc())
+        self.assertIn("v=0.20", rollback.describe(snap))
+        self.assertEqual(rollback.describe(None), "没有可回退的轮次")
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_main_has_rollback_command_and_ring(self):
+        source = (REPO / "main.py").read_text(encoding="utf-8")
+        self.assertIn("sub == \"rollback\"", source)
+        self.assertIn("_rollback_ring", source)
+        self.assertIn("_rollback_doc", source)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_runtime.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+"""PIPE-2 runtime tests: default pipeline assembly, switches, run_reply, fallback."""
+import unittest
+
+from biocore_model import pipeline as pl
+from biocore_model import runtime as rt
+
+
+class FakeEvent:
+    def __init__(self, text="", umo="umo-9", sender="u-9"):
+        self.message_str = text
+        self.unified_msg_origin = umo
+        self._sender = sender
+
+    def get_sender_id(self):
+        return self._sender
+
+
+class FakeCore:
+    def __init__(self):
+        self._snapshot = {"emotion": "calm", "intensity": 0.5, "v": 0.1,
+                          "a": 0.2, "stress": 0.1, "self_esteem": 0.7}
+        self.observed = []
+        self.loaded = []
+
+    def snapshot(self):
+        return dict(self._snapshot)
+
+    def observe(self, text, embedding=None):
+        self.observed.append(text)
+
+    def load_state(self, state):
+        self.loaded.append(dict(state))
+
+
+class BoomPipeline(pl.Pipeline):
+    def run(self, ctx=None, start=None):
+        raise RuntimeError("runtime boom")
+
+
+def request_ctx(text="你好", llm=None, core=None, memory=None):
+    meta = {"now": 1000.0}
+    if llm is not None:
+        meta["llm"] = llm
+    return rt.make_request_ctx(plugin=object(), event=FakeEvent(text),
+                               core=core or FakeCore(), text=text,
+                               memory=memory or [], now=1000.0, meta=meta)
+
+
+class BuildTest(unittest.TestCase):
+    def test_default_pipeline_order(self):
+        p = rt.build_default_pipeline()
+        self.assertEqual(p.names(),
+                         ["perceive", "memory", "bio", "decide", "expr_state",
+                          "expr_tone", "expr_intent", "think", "parse",
+                          "feedback", "present"])
+
+    def test_default_switches_reflect_in_status(self):
+        p = rt.build_default_pipeline()
+        rows = {row["name"]: row for row in p.get_status()["stages"]}
+        self.assertTrue(rows["memory"]["enabled"])
+        self.assertTrue(rows["think"]["enabled"])
+        off = rt.build_default_pipeline(switches={"memory": False, "bio": False})
+        rows = {row["name"]: row for row in off.get_status()["stages"]}
+        self.assertFalse(rows["memory"]["enabled"])
+        self.assertFalse(rows["bio"]["enabled"])
+        # think is in PIPE-1 REQUIRED_STAGES, so it stays registered; a missing
+        # llm already makes it a clean no-op instead of aborting the mainline.
+        locked = rt.build_default_pipeline(switches={"think": False})
+        rows = {row["name"]: row for row in locked.get_status()["stages"]}
+        self.assertTrue(rows["think"]["enabled"])
+
+    def test_singleton_identity_and_reset(self):
+        rt.reset_pipeline()
+        first = rt.get_pipeline()
+        self.assertIs(first, rt.get_pipeline())
+        rt.reset_pipeline()
+        self.assertIsNot(first, rt.get_pipeline())
+
+    def test_required_stages_cannot_be_disabled(self):
+        rt.reset_pipeline()
+        for name in rt.REQUIRED_STAGES:
+            self.assertRaises(ValueError, rt.set_enabled, name, False)
+
+
+class RunReplyTest(unittest.TestCase):
+    def test_end_to_end_with_llm(self):
+        ctx = request_ctx(llm=lambda prompt: "我在。")
+        out = rt.run_reply(ctx)
+        self.assertEqual(rt.reply_text(out), "我在。")
+        self.assertNotIn("pipeline_error", out["meta"])
+        names = [row["name"] for row in out["trace"]["stages"]]
+        self.assertEqual(names, list(rt.get_pipeline().names()))
+
+    def test_without_llm_has_no_reply_and_no_raise(self):
+        out = rt.run_reply(request_ctx())
+        self.assertEqual(rt.reply_text(out), "")
+        self.assertNotIn("pipeline_error", out["meta"])
+        self.assertIn("think", [row["stage"] for row in out["meta"]["skipped"]])
+
+    def test_abort_is_contained(self):
+        p = pl.Pipeline()
+        p.register(pl.Stage("perceive", lambda c: 1 / 0))
+        out = rt.run_reply(request_ctx(), pipeline=p)
+        self.assertEqual(out["meta"]["pipeline_error"]["kind"], "abort")
+        self.assertEqual(out["meta"]["pipeline_error"]["stage"], "perceive")
+
+    def test_exception_is_contained(self):
+        out = rt.run_reply(request_ctx(), pipeline=BoomPipeline())
+        self.assertEqual(out["meta"]["pipeline_error"]["kind"], "exception")
+
+    def test_legal_text_has_no_protocol_leak(self):
+        fence = chr(96) * 3
+        raw = ('好。<bc>{"e":"joy","i":0.6}</bc>' + fence + 'json\n'
+               + '{"e":"joy"}\n' + fence)
+        out = rt.run_reply(request_ctx(llm=lambda prompt: raw))
+        text = rt.reply_text(out)
+        self.assertTrue(text)
+        self.assertNotIn("<bc>", text)
+        self.assertNotIn("json", text)
+
+    def test_disabled_memory_stage_still_valid(self):
+        p = rt.build_default_pipeline(switches={"memory": False})
+        out = rt.run_reply(request_ctx(llm=lambda prompt: "嗯。"), pipeline=p)
+        rows = {row["name"]: row for row in out["trace"]["stages"]}
+        self.assertEqual(rows["memory"]["status"], "skipped")
+        self.assertEqual(rt.reply_text(out), "嗯。")
+
+    def test_think_error_does_not_abort(self):
+        def boom(prompt):
+            raise RuntimeError("provider down")
+        out = rt.run_reply(request_ctx(llm=boom))
+        self.assertNotIn("pipeline_error", out["meta"])
+        self.assertEqual(rt.reply_text(out), "")
+        self.assertIn("think", [row["stage"] for row in out["meta"]["skipped"]])
+
+
+class RequestCtxTest(unittest.TestCase):
+    def test_fields_and_side_effect_flags(self):
+        core = FakeCore()
+        ctx = request_ctx(core=core)
+        self.assertEqual(ctx["user"], "u-9")
+        self.assertEqual(ctx["umo"], "umo-9")
+        self.assertEqual(ctx["state"]["emotion"], "calm")
+        self.assertTrue(ctx["meta"]["shadow"])
+        self.assertFalse(ctx["meta"]["write_core"])
+        self.assertFalse(ctx["meta"]["observe"])
+
+    def test_shadow_run_does_not_touch_core(self):
+        core = FakeCore()
+        out = rt.run_reply(request_ctx(llm=lambda prompt: "ok", core=core))
+        self.assertEqual(core.observed, [])
+        self.assertEqual(core.loaded, [])
+        self.assertEqual(out["core"], core)
+
+    def test_trace_ring_recorded(self):
+        out = rt.run_reply(request_ctx(llm=lambda prompt: "hi"))
+        self.assertEqual(len(out["trace"]["stages"]), 11)
+        self.assertIn("ring", out["trace"])
+        self.assertGreaterEqual(len(out["trace"]["ring"]), 11)
+
+
+class StatusTest(unittest.TestCase):
+    def test_get_status_and_set_enabled(self):
+        rt.reset_pipeline()
+        rt.set_enabled("expr_intent", False)
+        rows = {row["name"]: row for row in rt.get_status()["stages"]}
+        self.assertFalse(rows["expr_intent"]["enabled"])
+        rt.set_enabled("expr_intent", True)
+        rows = {row["name"]: row for row in rt.get_status()["stages"]}
+        self.assertTrue(rows["expr_intent"]["enabled"])
+
+
+if __name__ == "__main__":
+    unittest.main()