dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_page_status_autonomy.py

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*-
+"""page_status autonomy: fake plugin variants ensure data.autonomy.state carries V/theta.
+
+Regression for the live bug: when self.data_dir is missing at page_status time,
+ui_settings.base_dir fell back to an old directory whose accumulator had None
+values, overwriting the real state. The fix resolves the authority dir from
+_data_dir/DATA_DIR and merges the accumulator outside the state try-block.
+"""
+import asyncio
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_model import plugin_routes as routes
+from biocore_model import ui_settings
+
+
+class FakeCore:
+    def snapshot(self): return {"v": 0.0, "a": 0.4}
+    def intent(self): return {}
+    def load_state(self, state): return None
+    def autonomy_state(self, relationship=None, now=None, persist=True):
+        return {"enabled": True, "ready": False, "V": 0.71, "theta": 0.60}
+
+
+class FakePlugin(routes.RoutesMixin):
+    def __init__(self, data_dir, *, with_data_dir=True, state_attr="method",
+                 state_raises=False):
+        self._tmp = data_dir
+        if with_data_dir:
+            self.data_dir = str(data_dir)
+        self._data_dir = data_dir
+        self.context = type("Ctx", (), {"persona_manager": None})()
+        self.cores = {}                       # empty cores
+        self.profile = {}
+        self.persona_text = ""
+        self.self_model = {}
+        self.enabled = True
+        self.inject_intent = True
+        self.proactive_reply = False
+        self.proactive_autonomy = False
+        self.proactive_send = False
+        self.memory_dedup_embedding = True
+        self._migration_note = ""
+        if state_attr == "method":
+            if state_raises:
+                def _state():
+                    raise RuntimeError("state source down")
+            else:
+                def _state():
+                    return {"source": "method"}
+            self._autonomy_readonly_state = _state
+        self._relationship_of = lambda data=None: {}
+        self._working_set_preview = lambda key: {}
+        self._ensure_autonomy_task = lambda: None
+        self._functions_public = lambda: {}
+        self._llm_provider_options = lambda: []
+        self._public_api_config = lambda: {}
+        self._memory_stats = lambda: {}
+        self._decayed_merge_count = lambda *a, **k: 0
+        self._event_archive = lambda *a, **k: []
+        self._insights = lambda *a, **k: []
+        self._astrbot_llm_default = lambda: None
+        self._astrbot_embedding_default = lambda: None
+        self._astrbot_rerank_default = lambda: None
+        self._astrbot_tts_default = lambda: None
+        self._astrbot_image_default = lambda: None
+        async def _kb_available(): return False
+        self._kb_available = _kb_available
+
+
+class PageStatusAutonomyTest(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.tmp = Path(self._tmp.name)
+        self.authority = self.tmp / "plugin_data" / "astrbot_plugin_biocore"
+        self.authority.mkdir(parents=True, exist_ok=True)
+        (self.authority / "ui_settings.json").write_text(json.dumps({
+            "autonomy": {"accumulator": {"V": 0.2838, "theta": 0.55,
+                                         "ticks_since_fire": 3}},
+            "schema": 1}, ensure_ascii=False), encoding="utf-8")
+        routes.DATA_DIR = self.authority
+        routes.MEMORY_DIR = self.tmp / "memory"
+        routes.STATE_DIR = self.tmp / "states"
+        routes.USER_DIR = self.tmp / "users"
+        routes.DEFAULT_PROFILE = {}
+        routes.DEFAULT_MEMORY_TRACE = {}
+        routes._memory_index_rows = lambda *a, **k: []
+        routes._relationship_rows = lambda *a, **k: []
+        routes.LLM_FUNCTIONS = ()
+        routes.LLM_FUNCTION_DEFAULTS = {}
+        for folder in (routes.MEMORY_DIR, routes.STATE_DIR, routes.USER_DIR):
+            folder.mkdir(parents=True, exist_ok=True)
+        # isolate from the real instance layout for attr-based tests
+        self._orig_module_file = routes._MODULE_FILE
+        routes._MODULE_FILE = (self.tmp / "no_instance" / "plugins" / "x"
+                               / "biocore_model" / "plugin_routes.py")
+
+    def tearDown(self):
+        routes._MODULE_FILE = self._orig_module_file
+        self._tmp.cleanup()
+
+    def _run(self, plugin):
+        out = asyncio.run(plugin.page_status())
+        self.assertEqual(out.get("status"), "ok")
+        return out["data"]["autonomy"]
+
+    def test_data_dir_set_and_state_attr_is_method(self):
+        plugin = FakePlugin(self.authority, with_data_dir=True, state_attr="method")
+        path = routes._authority_settings_path(plugin)
+        self.assertEqual(Path(str(path)), self.authority / "ui_settings.json")
+        automation = self._run(plugin)
+        self.assertEqual(set(automation), {"enabled", "send", "state", "_debug"})
+        state = automation["state"]
+        self.assertEqual(state["V"], 0.2838)
+        self.assertEqual(state["theta"], 0.55)
+        self.assertEqual(state["ticks_since_fire"], 3)
+
+    def test_data_dir_missing_falls_back_to_authority(self):
+        plugin = FakePlugin(self.authority, with_data_dir=False, state_attr="method")
+        path = routes._authority_settings_path(plugin)
+        self.assertEqual(Path(str(path)), self.authority / "ui_settings.json")
+        state = self._run(plugin)["state"]
+        self.assertEqual(state["V"], 0.2838)
+        self.assertEqual(state["theta"], 0.55)
+
+    def test_stale_data_dir_reads_injected_authority(self):
+        stale = self.tmp / "stale_A"
+        stale.mkdir(parents=True, exist_ok=True)
+        (stale / "ui_settings.json").write_text(json.dumps({
+            "autonomy": {"accumulator": {"V": None, "theta": None,
+                                         "ticks_since_fire": None}}},
+            ensure_ascii=False), encoding="utf-8")
+        plugin = FakePlugin(self.authority, with_data_dir=False, state_attr="method")
+        plugin.data_dir = str(stale)          # stale data_dir must not win
+        state = self._run(plugin)["state"]
+        self.assertEqual(state["V"], 0.2838)
+        self.assertEqual(state["theta"], 0.55)
+        self.assertIsNotNone(state["ticks_since_fire"])
+
+    def test_state_source_failure_still_merges_accumulator(self):
+        plugin = FakePlugin(self.authority, with_data_dir=False, state_attr="method",
+                            state_raises=True)
+        state = self._run(plugin)["state"]
+        self.assertEqual(state["V"], 0.2838)
+        self.assertEqual(state["theta"], 0.55)
+
+    def test_authority_file_survives_old_accumulator_none(self):
+        old = self.tmp / "old_A"
+        old.mkdir(parents=True, exist_ok=True)
+        (old / "ui_settings.json").write_text(json.dumps({
+            "autonomy": {"accumulator": {"V": None, "theta": None,
+                                         "ticks_since_fire": None}}},
+            ensure_ascii=False), encoding="utf-8")
+        plugin = FakePlugin(self.authority, with_data_dir=False, state_attr="method")
+        state = self._run(plugin)["state"]
+        self.assertEqual(state["V"], 0.2838)
+        self.assertIsNotNone(state["theta"])
+
+
+    def test_module_candidates_follow_instance_layout(self):
+        data_root = self.tmp / "inst" / "core" / "data"
+        mod_file = (data_root / "plugins" / "astrbot_plugin_biocore_standalone"
+                    / "biocore_model" / "plugin_routes.py")
+        routes._MODULE_FILE = mod_file
+        candidates = routes._module_candidate_paths()
+        self.assertEqual(Path(str(candidates[0])).resolve(),
+                         (data_root / "plugin_data" / "astrbot_plugin_biocore"
+                          / "ui_settings.json").resolve())
+        self.assertEqual(Path(str(candidates[1])).resolve(),
+                         (data_root / "plugins" / "astrbot_plugin_biocore_standalone"
+                          / "data" / "ui_settings.json").resolve())
+
+    def test_real_instance_authority_file(self):
+        authority = None
+        base = Path.home() / ".astrbot_launcher" / "instances"
+        for candidate in sorted(base.glob(
+                "*/core/data/plugin_data/astrbot_plugin_biocore/ui_settings.json")):
+            if candidate.is_file():
+                authority = candidate
+                break
+        if authority is None:
+            self.skipTest("no real AstrBot instance ui_settings.json")
+        data_root = authority.parents[2]      # .../core/data
+        routes._MODULE_FILE = (data_root / "plugins" / "astrbot_plugin_biocore_standalone"
+                               / "biocore_model" / "plugin_routes.py")
+        candidates = routes._module_candidate_paths()
+        self.assertEqual(candidates[0], authority)
+        self.assertTrue(candidates[0].exists())
+        acc = routes._read_accumulator(candidates[0])
+        self.assertTrue(acc)
+        self.assertTrue(any(value is not None for value in acc.values()))
+
+    def test_debug_field_reports_used_candidate(self):
+        data_root = self.tmp / "inst_debug" / "core" / "data"
+        authority = data_root / "plugin_data" / "astrbot_plugin_biocore"
+        authority.mkdir(parents=True, exist_ok=True)
+        (authority / "ui_settings.json").write_text(json.dumps({
+            "autonomy": {"accumulator": {"V": 0.2838, "theta": 0.55}},
+            "schema": 1}, ensure_ascii=False), encoding="utf-8")
+        routes._MODULE_FILE = (data_root / "plugins" / "x"
+                               / "biocore_model" / "plugin_routes.py")
+        plugin = FakePlugin(self.authority, with_data_dir=False, state_attr="method")
+        automation = self._run(plugin)
+        self.assertEqual(automation["state"]["V"], 0.2838)
+        debug = automation["_debug"]
+        self.assertEqual(debug["used"], debug["candidates"][0])
+        self.assertTrue(debug["exists"][0])
+        self.assertIn("V", debug["acc_keys"])
+        self.assertIn("theta", debug["acc_keys"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_pipeline.py

@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import pipeline as pl
+
+
+def stage(name, **kw):
+    kw.setdefault("run", lambda ctx: {name: True})
+    return pl.Stage(name, **kw)
+
+
+class PipelineTest(unittest.TestCase):
+    def test_order(self):
+        order = []
+        p = pl.Pipeline([stage("a", run=lambda c: order.append("a") or {}), stage("b", run=lambda c: order.append("b") or {})])
+        p.run({})
+        self.assertEqual(order, ["a", "b"])
+    def test_skip_disabled(self):
+        p = pl.Pipeline([stage("a"), stage("b")])
+        p.set_enabled("a", False)
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["status"], "skipped")
+    def test_required_cannot_disable(self):
+        p = pl.Pipeline([stage("perceive")])
+        with self.assertRaises(ValueError):
+            p.set_enabled("perceive", False)
+    def test_exception_continues(self):
+        p = pl.Pipeline([stage("a", run=lambda c: 1 / 0), stage("b")])
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["status"], "failed")
+        self.assertEqual(ctx["trace"]["stages"][1]["status"], "ok")
+    def test_required_failure_aborts(self):
+        p = pl.Pipeline([stage("think", required=True, run=lambda c: 1 / 0)])
+        with self.assertRaises(pl.PipelineAbort):
+            p.run({})
+    def test_timeout_skipped(self):
+        import time
+        p = pl.Pipeline([stage("slow", timeout_ms=50, run=lambda c: time.sleep(0.2)), stage("b")])
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["status"], "timeout")
+        self.assertEqual(ctx["trace"]["stages"][1]["status"], "ok")
+    def test_required_timeout_aborts(self):
+        import time
+        p = pl.Pipeline([stage("express", timeout_ms=30, run=lambda c: time.sleep(0.15))])
+        with self.assertRaises(pl.PipelineAbort):
+            p.run({})
+    def test_on_error_abort(self):
+        p = pl.Pipeline([stage("a", on_error="abort", run=lambda c: 1 / 0)])
+        with self.assertRaises(pl.PipelineAbort):
+            p.run({})
+    def test_trace_fields(self):
+        p = pl.Pipeline([stage("a")])
+        ctx = p.run({})
+        record = ctx["trace"]["stages"][0]
+        for key in ("name", "ms", "status", "note"):
+            self.assertIn(key, record)
+    def test_ring_limit_50(self):
+        p = pl.Pipeline([stage("a")])
+        for _ in range(60):
+            p.run({})
+        self.assertEqual(len(p._ring), 50)
+    def test_get_status_fields(self):
+        p = pl.Pipeline([stage("a"), stage("b")])
+        status = p.get_status()
+        row = status["stages"][0]
+        for key in ("name", "required", "enabled", "last_status", "last_ms"):
+            self.assertIn(key, row)
+    def test_get_status_after_run(self):
+        p = pl.Pipeline([stage("a")])
+        p.run({})
+        status = p.get_status()
+        self.assertEqual(status["stages"][0]["last_status"], "ok")
+        self.assertIn("stages", status["last_trace"])
+    def test_each_non_required_disabled_still_valid(self):
+        names = ["a", "b", "c"]
+        for name in names:
+            p = pl.Pipeline([stage(n) for n in names])
+            p.set_enabled(name, False)
+            ctx = p.run({})
+            self.assertIn("trace", ctx)
+    def test_unknown_set_enabled(self):
+        p = pl.Pipeline([stage("a")])
+        with self.assertRaises(KeyError):
+            p.set_enabled("nope", False)
+    def test_ctx_updated_by_stage(self):
+        p = pl.Pipeline([stage("a", run=lambda c: {"value": 7})])
+        self.assertEqual(p.run({})["value"], 7)
+    def test_ctx_input_preserved(self):
+        p = pl.Pipeline([stage("a")])
+        ctx = p.run({"event": "m1"})
+        self.assertEqual(ctx["event"], "m1")
+    def test_default_stages_all_required(self):
+        stages = pl.default_stages()
+        self.assertEqual([s.name for s in stages], ["perceive", "think", "express", "present"])
+        self.assertTrue(all(s.required for s in stages))
+    def test_no_main_import(self):
+        import pathlib
+        source = pathlib.Path(__file__).resolve().parent.parent.joinpath("pipeline.py").read_text(encoding="utf-8")
+        self.assertNotIn("import main", source)
+
+
+class FakeClock:
+    """Injected clock: deterministic seconds, advanced explicitly by a stage."""
+
+    def __init__(self):
+        self.now = 0.0
+
+    def __call__(self):
+        return self.now
+
+    def advance(self, seconds):
+        self.now += float(seconds)
+        return self.now
+
+
+class PipelineContractTest(unittest.TestCase):
+    def test_ctx_contract_fields(self):
+        ctx = pl.make_ctx()
+        self.assertEqual(set(ctx.keys()), set(pl.CTX_FIELDS))
+        self.assertEqual(len(pl.CTX_FIELDS), 16)
+        self.assertEqual(ctx["trace"]["stages"], [])
+
+    def test_run_fills_all_ctx_fields(self):
+        p = pl.Pipeline([stage("a")])
+        ctx = p.run({"event": {"text": "hi"}})
+        for field in pl.CTX_FIELDS:
+            self.assertIn(field, ctx)
+        self.assertEqual(ctx["event"], {"text": "hi"})
+
+    def test_run_does_not_mutate_input(self):
+        p = pl.Pipeline([stage("a")])
+        given = {"event": "m1"}
+        p.run(given)
+        self.assertEqual(given, {"event": "m1"})
+
+    def test_register_appends(self):
+        p = pl.Pipeline([stage("a")])
+        p.register(stage("b"))
+        self.assertEqual(p.names(), ["a", "b"])
+
+    def test_register_accepts_dict(self):
+        p = pl.Pipeline()
+        p.register({"name": "a", "run": lambda ctx: None})
+        self.assertEqual(p.names(), ["a"])
+
+    def test_register_duplicate_raises(self):
+        p = pl.Pipeline([stage("a")])
+        with self.assertRaises(ValueError):
+            p.register(stage("a"))
+
+    def test_register_bad_type(self):
+        p = pl.Pipeline()
+        with self.assertRaises(TypeError):
+            p.register("nope")
+
+    def test_stage_rejects_empty_name(self):
+        with self.assertRaises(ValueError):
+            pl.Stage("", lambda ctx: None)
+
+    def test_stage_rejects_non_callable_run(self):
+        with self.assertRaises(TypeError):
+            pl.Stage("a", "not-callable")
+
+    def test_stage_rejects_negative_timeout(self):
+        with self.assertRaises(ValueError):
+            pl.Stage("a", lambda ctx: None, timeout_ms=-1)
+
+    def test_invalid_on_error_normalized(self):
+        st = pl.Stage("a", lambda ctx: None, on_error="explode")
+        self.assertEqual(st.on_error, "skip")
+
+    def test_start_by_name(self):
+        order = []
+        p = pl.Pipeline([stage("a", run=lambda c: order.append("a") or {}),
+                         stage("b", run=lambda c: order.append("b") or {}),
+                         stage("c", run=lambda c: order.append("c") or {})])
+        ctx = p.run({}, start="b")
+        self.assertEqual(order, ["b", "c"])
+        self.assertEqual([row["status"] for row in ctx["trace"]["stages"]],
+                         ["skipped", "ok", "ok"])
+        self.assertEqual(ctx["trace"]["stages"][0]["note"], "before_start")
+
+    def test_start_by_index(self):
+        order = []
+        p = pl.Pipeline([stage("a", run=lambda c: order.append("a") or {}),
+                         stage("b", run=lambda c: order.append("b") or {})])
+        p.run({}, start=1)
+        self.assertEqual(order, ["b"])
+
+    def test_start_unknown_raises(self):
+        p = pl.Pipeline([stage("a")])
+        with self.assertRaises(KeyError):
+            p.run({}, start="nope")
+
+    def test_start_out_of_range(self):
+        p = pl.Pipeline([stage("a")])
+        with self.assertRaises(IndexError):
+            p.run({}, start=5)
+
+    def test_status_enabled_reflects_toggle(self):
+        p = pl.Pipeline([stage("a"), stage("b")])
+        p.set_enabled("a", False)
+        rows = {row["name"]: row for row in p.get_status()["stages"]}
+        self.assertFalse(rows["a"]["enabled"])
+        self.assertTrue(rows["b"]["enabled"])
+        p.set_enabled("a", True)
+        rows = {row["name"]: row for row in p.get_status()["stages"]}
+        self.assertTrue(rows["a"]["enabled"])
+
+    def test_all_required_stages_cannot_disable(self):
+        for name in pl.REQUIRED_STAGES:
+            p = pl.Pipeline([stage(name)])
+            with self.assertRaises(ValueError):
+                p.set_enabled(name, False)
+            self.assertTrue(p.set_enabled(name, True))
+
+    def test_fallback_used_on_error(self):
+        p = pl.Pipeline([
+            pl.Stage("a", lambda c: 1 / 0, on_error="fallback",
+                     fallback=lambda c: {"reply": "fb"}),
+            stage("b")])
+        ctx = p.run({})
+        first = ctx["trace"]["stages"][0]
+        self.assertEqual(first["status"], "failed")
+        self.assertIn("fallback:ok", first["note"])
+        self.assertEqual(ctx["reply"], "fb")
+        self.assertEqual(ctx["trace"]["stages"][1]["status"], "ok")
+
+    def test_fallback_failure_keeps_note(self):
+        def bad_fallback(ctx):
+            raise ValueError("boom")
+        p = pl.Pipeline([pl.Stage("a", lambda c: 1 / 0, on_error="fallback",
+                                  fallback=bad_fallback)])
+        ctx = p.run({})
+        self.assertIn("fallback:ValueError", ctx["trace"]["stages"][0]["note"])
+
+    def test_on_error_abort_non_required(self):
+        p = pl.Pipeline([pl.Stage("a", lambda c: 1 / 0, on_error="abort")])
+        with self.assertRaises(pl.PipelineAbort):
+            p.run({})
+
+    def test_clock_injected_ms_is_deterministic(self):
+        clock = FakeClock()
+
+        def run(ctx):
+            clock.advance(0.012)
+            return {}
+
+        p = pl.Pipeline([pl.Stage("a", run, timeout_ms=1000)], clock=clock)
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["ms"], 12.0)
+        self.assertEqual(p.get_status()["stages"][0]["last_ms"], 12.0)
+
+    def test_timeout_with_injected_clock(self):
+        clock = FakeClock()
+
+        def run(ctx):
+            clock.advance(0.2)
+            return {}
+
+        p = pl.Pipeline([pl.Stage("a", run, timeout_ms=50), stage("b")], clock=clock)
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["status"], "timeout")
+        self.assertEqual(ctx["trace"]["stages"][1]["status"], "ok")
+
+    def test_zero_timeout_never_times_out(self):
+        clock = FakeClock()
+
+        def run(ctx):
+            clock.advance(5.0)
+            return {}
+
+        p = pl.Pipeline([pl.Stage("a", run, timeout_ms=0)], clock=clock)
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["status"], "ok")
+
+    def test_explicit_timeout_error_maps_to_timeout(self):
+        def run(ctx):
+            raise TimeoutError("stage self-report")
+
+        p = pl.Pipeline([pl.Stage("a", run, timeout_ms=0)])
+        ctx = p.run({})
+        self.assertEqual(ctx["trace"]["stages"][0]["status"], "timeout")
+
+    def test_ring_keeps_last_50_in_order(self):
+        p = pl.Pipeline([stage("a"), stage("b")])
+        for _ in range(30):
+            p.run({})
+        self.assertEqual(len(p._ring), 50)
+        self.assertEqual(p._ring[-1]["name"], "b")
+        self.assertEqual(p._ring[-2]["name"], "a")
+
+    def test_abort_attaches_trace_and_updates_status(self):
+        p = pl.Pipeline([pl.Stage("perceive", lambda c: 1 / 0), stage("b")])
+        try:
+            p.run({})
+        except pl.PipelineAbort as exc:
+            self.assertEqual(exc.stage_name, "perceive")
+            self.assertEqual(exc.trace["stages"][0]["status"], "failed")
+        else:
+            self.fail("PipelineAbort not raised")
+        status = p.get_status()
+        self.assertEqual(status["stages"][0]["last_status"], "failed")
+        self.assertEqual(status["last_trace"]["stages"][0]["status"], "failed")
+
+    def test_disable_each_non_required_stage_still_valid(self):
+        for name in ("a", "b", "c"):
+            p = pl.Pipeline([stage("a"), stage("b"), stage("c")])
+            p.set_enabled(name, False)
+            ctx = p.run({})
+            rows = {row["name"]: row for row in ctx["trace"]["stages"]}
+            self.assertEqual(rows[name]["status"], "skipped")
+            self.assertEqual(rows[name]["note"], "disabled")
+            self.assertEqual(sum(1 for row in rows.values() if row["status"] == "ok"), 2)
+            for field in pl.CTX_FIELDS:
+                self.assertIn(field, ctx)
+
+    def test_skip_note_and_ms(self):
+        p = pl.Pipeline([stage("a")])
+        p.set_enabled("a", False)
+        ctx = p.run({})
+        row = ctx["trace"]["stages"][0]
+        self.assertEqual(row["ms"], 0.0)
+        self.assertEqual(p.get_status()["stages"][0]["last_status"], "skipped")
+
+    def test_default_stages_run_produces_reply(self):
+        p = pl.Pipeline(pl.default_stages())
+        ctx = p.run(pl.make_ctx(event={"text": "hi"}))
+        self.assertTrue(ctx["reply"])
+        self.assertEqual([row["status"] for row in ctx["trace"]["stages"]],
+                         ["ok", "ok", "ok", "ok"])
+
+    def test_status_fields_and_trace_contract(self):
+        p = pl.Pipeline([stage("a")])
+        ctx = p.run({})
+        row = ctx["trace"]["stages"][0]
+        self.assertEqual(set(row.keys()), {"name", "ms", "status", "note"})
+        status = p.get_status()
+        self.assertEqual(set(status.keys()), {"stages", "last_trace"})
+        self.assertEqual(set(status["stages"][0].keys()),
+                         {"name", "required", "enabled", "last_status", "last_ms"})
+        self.assertIn("ring", status["last_trace"])
+
+
+if __name__ == "__main__":
+    unittest.main()