dsh-biocore 0.2.0 → 0.3.1

package/python/biocore_model/tests/test_pipeline_api.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+"""PIPE-3 pipeline API tests: status, toggle, persistence, dry-run, routes."""
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from biocore_model import pipeline_api as pa
+from biocore_model import runtime as rt
+
+
+class FakePlugin:
+    def __init__(self, data_dir, pipeline_mode="shadow"):
+        self.data_dir = str(data_dir)
+        self.pipeline_mode = pipeline_mode
+
+
+class Base(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.tmp = Path(self._tmp.name)
+        self.plugin = FakePlugin(self.tmp)
+        rt.reset_pipeline()
+        rt.apply_switches({})
+        pa.reset_boot()
+
+    def tearDown(self):
+        rt.apply_switches({})
+        rt.reset_pipeline()
+        pa.reset_boot()
+        self._tmp.cleanup()
+
+    def settings(self):
+        return json.loads((self.tmp / "ui_settings.json").read_text(encoding="utf-8"))
+
+
+class StatusTest(Base):
+    def test_status_payload_structure(self):
+        payload = pa.payload_status(self.plugin)
+        for key in ("mode", "stages", "last_trace", "updated_ts", "schema", "switches"):
+            self.assertIn(key, payload)
+        self.assertEqual(payload["mode"], "shadow")
+        self.assertEqual(len(payload["stages"]), 11)
+        for row in payload["stages"]:
+            self.assertEqual(set(row), {"name", "required", "enabled",
+                                        "last_status", "last_ms"})
+
+    def test_status_stage_order_matches_runtime(self):
+        payload = pa.payload_status(self.plugin)
+        self.assertEqual([row["name"] for row in payload["stages"]],
+                         list(rt.get_pipeline().names()))
+
+    def test_status_updated_ts_and_schema(self):
+        payload = pa.payload_status(self.plugin)
+        self.assertIsInstance(payload["updated_ts"], float)
+        self.assertEqual(payload["schema"], pa.SCHEMA)
+
+    def test_status_reflects_applied_switches(self):
+        rt.apply_switches({"memory": False})
+        payload = pa.payload_status(self.plugin)
+        rows = {row["name"]: row for row in payload["stages"]}
+        self.assertFalse(rows["memory"]["enabled"])
+        self.assertFalse(payload["switches"]["memory"])
+
+
+class ToggleTest(Base):
+    def test_toggle_non_required_ok(self):
+        result = pa.payload_toggle(self.plugin, "expr_intent", False)
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["saved"])
+        rows = {row["name"]: row for row in result["stages"]}
+        self.assertFalse(rows["expr_intent"]["enabled"])
+
+    def test_toggle_required_rejected(self):
+        for name in pa.REQUIRED_STAGES:
+            result = pa.payload_toggle(self.plugin, name, False)
+            self.assertFalse(result["ok"], name)
+            self.assertEqual(result["message"], "required_stage")
+            rows = {row["name"]: row for row in result["stages"]}
+            self.assertTrue(rows[name]["enabled"])
+
+    def test_toggle_think_rejected(self):
+        result = pa.payload_toggle(self.plugin, "think", False)
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["message"], "required_stage")
+
+    def test_toggle_unknown_stage(self):
+        result = pa.payload_toggle(self.plugin, "nope", True)
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["message"], "unknown_stage")
+
+    def test_toggle_name_required(self):
+        result = pa.payload_toggle(self.plugin, "", True)
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["message"], "name_required")
+
+    def test_toggle_persists_to_ui_settings(self):
+        pa.payload_toggle(self.plugin, "expr_tone", False)
+        data = self.settings()
+        stages = data["autonomy"]["pipeline_stages"]
+        self.assertFalse(stages["expr_tone"])
+        self.assertEqual(data["schema"], 1)
+
+    def test_persistence_reload(self):
+        pa.payload_toggle(self.plugin, "memory", False)
+        pa.reset_boot()
+        rt.reset_pipeline()
+        other = FakePlugin(self.tmp)
+        payload = pa.payload_status(other)
+        rows = {row["name"]: row for row in payload["stages"]}
+        self.assertFalse(rows["memory"]["enabled"])
+
+    def test_switches_roundtrip(self):
+        saved = pa.save_switches(self.plugin, {"memory": False, "bio": True})
+        self.assertTrue(saved["ok"])
+        self.assertEqual(pa.load_switches(self.plugin),
+                         {"memory": False, "bio": True})
+
+    def test_boot_is_idempotent(self):
+        pa.reset_boot()
+        self.assertTrue(pa.boot(self.plugin))
+        self.assertFalse(pa.boot(self.plugin))
+
+
+class DryrunTest(Base):
+    def test_dryrun_structure(self):
+        result = pa.payload_dryrun(self.plugin, "今天有点累", now=1000.0)
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["mode"], "dryrun")
+        self.assertEqual(result["stages"], 11)
+        self.assertEqual(len(result["trace"]["stages"]), 11)
+        self.assertTrue(result["out_preview"])
+        self.assertIsNone(result["error"])
+
+    def test_dryrun_empty_text(self):
+        result = pa.payload_dryrun(self.plugin, "   ")
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["message"], "sample_text_required")
+
+    def test_dryrun_has_no_side_effects(self):
+        captured = {}
+
+        def fake_make_ctx(**kwargs):
+            captured.update(kwargs)
+            return {"meta": {"dryrun": True, "write_core": False,
+                             "observe": False, "llm": None, "now": 1000.0},
+                    "text": kwargs.get("text") or "", "trace": {"stages": []}}
+
+        with mock.patch.object(rt, "make_request_ctx", side_effect=fake_make_ctx), \
+                mock.patch.object(rt, "run_reply", return_value={
+                    "trace": {"stages": []}, "reply": "", "state_text": "状态块",
+                    "meta": {"dryrun": True}}):
+            result = pa.payload_dryrun(self.plugin, "样例", now=1000.0)
+        self.assertTrue(result["ok"])
+        self.assertIsNone(captured.get("core"))
+        meta = captured.get("meta")
+        self.assertTrue(meta["dryrun"])
+        self.assertFalse(meta["write_core"])
+        self.assertFalse(meta["observe"])
+        self.assertIsNone(meta["llm"])
+        self.assertFalse((self.tmp / "ui_settings.json").exists())
+
+    def test_dryrun_does_not_create_settings_file(self):
+        pa.payload_dryrun(self.plugin, "你好", now=5.0)
+        self.assertFalse((self.tmp / "ui_settings.json").exists())
+
+
+class RouteTest(unittest.TestCase):
+    def test_main_routes_and_auth_present(self):
+        root = Path(__file__).resolve().parent.parent.parent
+        source = (root / "main.py").read_text(encoding="utf-8")
+        for path in ('/page/pipeline"', '/page/pipeline_toggle"',
+                     '/page/pipeline_dryrun"'):
+            self.assertIn(path, source)
+        self.assertIn("self.page_pipeline, [\"GET\"]", source)
+        self.assertIn("self.page_pipeline_toggle, [\"POST\"]", source)
+        self.assertIn("self.page_pipeline_dryrun, [\"POST\"]", source)
+        self.assertGreaterEqual(source.count("_pa.payload_dryrun"), 1)
+        toggle_block = source.split("async def page_pipeline_toggle", 1)[1].split(
+            "async def page_pipeline_dryrun", 1)[0]
+        dry_block = source.split("async def page_pipeline_dryrun", 1)[1].split(
+            "async def generate_manual_insight", 1)[0]
+        self.assertIn("_page_is_local_admin", toggle_block)
+        self.assertIn("_page_is_local_admin", dry_block)
+        status_block = source.split("async def page_pipeline(self)", 1)[1].split(
+            "async def page_pipeline_toggle", 1)[0]
+        self.assertIn("payload_status", status_block)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_pipeline_mode.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+"""PIPE-4 mode tests: shadow/active switching, prompt output, fallback, safety."""
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_model import pipeline as pl
+from biocore_model import pipeline_api as pa
+from biocore_model import runtime as rt
+
+
+class FakePlugin:
+    def __init__(self, data_dir):
+        self.data_dir = str(data_dir)
+
+
+class FakeEvent:
+    def __init__(self, text="", umo="umo-7", sender="u-7"):
+        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": "sadness", "intensity": 0.6, "self_esteem": 0.4,
+                          "regulation": "suppress", "v": 0.1, "a": 0.4, "stress": 0.3}
+        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))
+
+
+def make_ctx(text="今天好累", core=None, meta=None):
+    return rt.make_request_ctx(plugin=None, event=FakeEvent(text),
+                               core=core if core is not None else FakeCore(),
+                               text=text, memory=[], now=1000.0, meta=meta or {})
+
+
+class Base(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.tmp = Path(self._tmp.name)
+        self.plugin = FakePlugin(self.tmp)
+        rt.reset_mode()
+        rt.apply_switches({})
+        rt.reset_pipeline()
+        pa.reset_boot()
+
+    def tearDown(self):
+        rt.reset_mode()
+        rt.apply_switches({})
+        rt.reset_pipeline()
+        pa.reset_boot()
+        self._tmp.cleanup()
+
+
+class ModeTest(Base):
+    def test_default_mode_is_shadow(self):
+        self.assertEqual(rt.MODE_DEFAULT, "shadow")
+        self.assertEqual(rt.get_mode(), "shadow")
+
+    def test_apply_mode_switches_without_restart(self):
+        before = rt.get_pipeline()
+        self.assertEqual(rt.apply_mode("active"), "active")
+        self.assertEqual(rt.get_mode(), "active")
+        self.assertIs(rt.get_pipeline(), before)
+        self.assertEqual(rt.apply_mode("shadow"), "shadow")
+
+    def test_apply_mode_invalid_rejected(self):
+        with self.assertRaises(ValueError):
+            rt.apply_mode("turbo")
+        self.assertEqual(rt.get_mode(), "shadow")
+
+    def test_save_mode_persists_to_ui_settings(self):
+        saved = pa.save_mode(self.plugin, "active")
+        self.assertTrue(saved["ok"])
+        data = json.loads((self.tmp / "ui_settings.json").read_text(encoding="utf-8"))
+        self.assertEqual(data["autonomy"]["pipeline_mode"], "active")
+        self.assertEqual(rt.get_mode(), "active")
+
+    def test_load_mode_default_and_roundtrip(self):
+        self.assertEqual(pa.load_mode(self.plugin), "shadow")
+        pa.save_mode(self.plugin, "active")
+        self.assertEqual(pa.load_mode(self.plugin), "active")
+
+    def test_boot_applies_persisted_active_mode(self):
+        pa.save_mode(self.plugin, "active")
+        rt.reset_mode()
+        pa.reset_boot()
+        other = FakePlugin(self.tmp)
+        self.assertTrue(pa.boot(other))
+        self.assertEqual(rt.get_mode(), "active")
+
+    def test_payload_mode_get_and_set(self):
+        self.assertEqual(pa.payload_mode(self.plugin)["mode"], "shadow")
+        result = pa.payload_mode(self.plugin, "active")
+        self.assertTrue(result["ok"])
+        self.assertEqual(result["mode"], "active")
+        self.assertEqual(pa.payload_mode(self.plugin)["mode"], "active")
+
+    def test_payload_mode_invalid(self):
+        result = pa.payload_mode(self.plugin, "loud")
+        self.assertFalse(result["ok"])
+        self.assertEqual(result["message"], "invalid_mode")
+
+
+class PromptTest(Base):
+    def test_shadow_run_reply_has_no_prompt_keys(self):
+        out = rt.run_reply(make_ctx())
+        self.assertNotIn("prompt_system", out)
+        self.assertNotIn("prompt_user", out)
+        self.assertIn("trace", out)
+
+    def test_active_run_prompt_structure(self):
+        rt.apply_mode("active")
+        out = rt.run_prompt(make_ctx())
+        self.assertIsNotNone(out)
+        for key in ("prompt_system", "prompt_user", "trace", "order"):
+            self.assertIn(key, out)
+        self.assertTrue(out["prompt_user"])
+        self.assertEqual(len(out["trace"]["stages"]), 11)
+
+    def test_active_prompt_contains_state_and_protocol(self):
+        rt.apply_mode("active")
+        out = rt.run_prompt(make_ctx())
+        self.assertIn("sadness", out["prompt_user"])
+        self.assertNotIn("【输出格式", out["prompt_system"])
+        self.assertNotIn("<bc>", out["prompt_system"])
+        self.assertNotIn("【输出格式", out["prompt_user"])
+
+    def test_active_prompt_uses_persona_opts(self):
+        rt.apply_mode("active")
+        out = rt.run_prompt(make_ctx(meta={"template_opts": {
+            "persona": "你是小助手", "speak_style": "口语"}}))
+        self.assertIn("小助手", out["prompt_system"])
+        self.assertIn("口语", out["prompt_system"])
+
+    def test_active_failure_returns_none(self):
+        rt.apply_mode("active")
+        bad = pl.Pipeline()
+        bad.register(pl.Stage("perceive", lambda ctx: 1 / 0))
+        self.assertIsNone(rt.run_prompt(make_ctx(), pipeline=bad))
+
+    def test_active_empty_ctx_returns_none(self):
+        rt.apply_mode("active")
+        self.assertIsNone(rt.run_prompt(rt.make_request_ctx()))
+
+    def test_mode_switch_routes_behavior_in_one_process(self):
+        shadow = rt.run_reply(make_ctx())
+        self.assertNotIn("prompt_user", shadow)
+        rt.apply_mode("active")
+        active = rt.run_prompt(make_ctx())
+        self.assertTrue(active and active["prompt_user"])
+        rt.apply_mode("shadow")
+        again = rt.run_reply(make_ctx())
+        self.assertNotIn("prompt_user", again)
+
+
+    def test_active_run_reply_returns_prompt_payload(self):
+        rt.apply_mode("active")
+        out = rt.run_reply(make_ctx())
+        for key in ("prompt_system", "prompt_user", "trace"):
+            self.assertIn(key, out)
+        self.assertTrue(out["prompt_user"])
+
+    def test_active_run_reply_failure_returns_empty_dict(self):
+        rt.apply_mode("active")
+        bad = pl.Pipeline()
+        bad.register(pl.Stage("perceive", lambda ctx: 1 / 0))
+        self.assertEqual(rt.run_reply(make_ctx(), pipeline=bad), {})
+
+
+class SafetyTest(Base):
+    def test_shadow_does_not_write_core(self):
+        core = FakeCore()
+        rt.run_reply(make_ctx(core=core, meta={"observe_core": True}))
+        self.assertEqual(core.observed, [])
+        self.assertEqual(core.loaded, [])
+
+    def test_active_observe_core_default_false(self):
+        rt.apply_mode("active")
+        core = FakeCore()
+        out = rt.run_prompt(make_ctx(core=core))
+        self.assertIsNotNone(out)
+        self.assertEqual(core.observed, [])
+        self.assertEqual(core.loaded, [])
+
+    def test_active_observe_core_true_calls_observe(self):
+        rt.apply_mode("active")
+        core = FakeCore()
+        out = rt.run_prompt(make_ctx(core=core, meta={"observe_core": True}))
+        self.assertIsNotNone(out)
+        self.assertEqual(core.observed, ["今天好累"])
+        self.assertEqual(core.loaded, [])
+
+    def test_trace_has_stage_ms(self):
+        rt.apply_mode("active")
+        out = rt.run_prompt(make_ctx())
+        stages = out["trace"]["stages"]
+        self.assertEqual([row["name"] for row in stages],
+                         ["perceive", "memory", "bio", "decide", "expr_state",
+                          "expr_tone", "expr_intent", "think", "parse",
+                          "feedback", "present"])
+        for row in stages:
+            self.assertIsInstance(row["ms"], float)
+            self.assertGreaterEqual(row["ms"], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_plugin_config.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+import json, tempfile, unittest
+from pathlib import Path
+from biocore_model import plugin_config
+
+
+class PluginConfigPersistTest(unittest.TestCase):
+    def _file(self, tmp, data, bom=False):
+        path = Path(tmp) / plugin_config.FILE_NAME
+        text = json.dumps(data, ensure_ascii=False)
+        path.write_text(text, encoding="utf-8-sig" if bom else "utf-8")
+        return path
+
+    def test_persist_updates_and_reads_back(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._file(tmp, {"reply_split_enabled": False, "reply_split_mode": "punct"})
+            old = plugin_config.find_config
+            plugin_config.find_config = lambda plugin=None: path
+            try:
+                result = plugin_config.persist_updates({"reply_split_enabled": True, "reply_split_mode": "astrbot"})
+            finally:
+                plugin_config.find_config = old
+            self.assertTrue(result["ok"])
+            data = json.loads(path.read_text(encoding="utf-8"))
+            self.assertTrue(data["reply_split_enabled"]); self.assertEqual(data["reply_split_mode"], "astrbot")
+
+    def test_bom_preserved_when_present(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._file(tmp, {"x": 1}, bom=True)
+            old = plugin_config.find_config
+            plugin_config.find_config = lambda plugin=None: path
+            try:
+                plugin_config.persist_updates({"y": 2})
+            finally:
+                plugin_config.find_config = old
+            self.assertTrue(path.read_bytes().startswith(b"\xef\xbb\xbf"))
+            self.assertEqual(json.loads(path.read_text(encoding="utf-8-sig"))["y"], 2)
+
+    def test_no_bom_written_without_bom(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._file(tmp, {"x": 1})
+            old = plugin_config.find_config
+            plugin_config.find_config = lambda plugin=None: path
+            try:
+                plugin_config.persist_updates({"y": 2})
+            finally:
+                plugin_config.find_config = old
+            self.assertFalse(path.read_bytes().startswith(b"\xef\xbb\xbf"))
+
+    def test_backup_created(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._file(tmp, {"x": 1})
+            old = plugin_config.find_config
+            plugin_config.find_config = lambda plugin=None: path
+            try:
+                plugin_config.persist_updates({"x": 2})
+            finally:
+                plugin_config.find_config = old
+            self.assertEqual(len(list(Path(tmp).glob(plugin_config.FILE_NAME + ".bak_replysplit_*"))), 1)
+
+    def test_backup_rotation_keeps_three(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._file(tmp, {"x": 1})
+            old = plugin_config.find_config
+            plugin_config.find_config = lambda plugin=None: path
+            try:
+                for index in range(5):
+                    plugin_config.persist_updates({"x": index})
+            finally:
+                plugin_config.find_config = old
+            self.assertLessEqual(len(list(Path(tmp).glob(plugin_config.FILE_NAME + ".bak_replysplit_*"))), 3)
+
+    def test_missing_file_reports_failure(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            old = plugin_config.find_config
+            plugin_config.find_config = lambda plugin=None: None
+            try:
+                result = plugin_config.persist_updates({"x": 1})
+            finally:
+                plugin_config.find_config = old
+            self.assertFalse(result["ok"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_policy_learning.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+import random, unittest
+from biocore_model import policy_learning as pl
+
+class PolicyLearningTest(unittest.TestCase):
+    def table(self):
+        t = {}
+        t = pl.update(t, "expect|secure|day", "approach", 1.0)
+        for _ in range(2):
+            t = pl.update(t, "expect|secure|day", "approach", 1.0)
+        for _ in range(4):
+            t = pl.update(t, "expect|secure|day", "share", -1.0)
+        return t
+
+    def test_update_positive(self):
+        t = pl.update({}, "c", "approach", 1.0)
+        self.assertGreater(t["c"]["approach"]["q"], 0.0)
+        self.assertEqual(t["c"]["approach"]["n"], 1)
+
+    def test_update_negative(self):
+        t = pl.update({}, "c", "share", -1.0)
+        self.assertLess(t["c"]["share"]["q"], 0.0)
+
+    def test_update_alpha(self):
+        low = pl.update({}, "c", "approach", 1.0, alpha=0.1)
+        high = pl.update({}, "c", "approach", 1.0, alpha=0.5)
+        self.assertGreater(high["c"]["approach"]["q"], low["c"]["approach"]["q"])
+
+    def test_update_immutable(self):
+        original = {}
+        updated = pl.update(original, "c", "approach", 1.0)
+        self.assertEqual(original, {})
+        self.assertNotIn("c", original)
+        self.assertIn("c", updated)
+
+    def test_reward_responded(self):
+        self.assertGreater(pl.reward(True, 1.0, 0.0), pl.reward(False, 1.0, 0.0))
+
+    def test_reward_speed(self):
+        self.assertGreater(pl.reward(True, 1.0, 0.0), pl.reward(True, 100.0, 0.0))
+
+    def test_reward_clamped(self):
+        self.assertLessEqual(pl.reward(True, 0.0, 5.0), 1.0)
+        self.assertGreaterEqual(pl.reward(True, 0.0, -5.0), -0.3)
+
+    def test_choose_greedy(self):
+        t = self.table()
+        result = pl.choose("expect|secure|day", t, epsilon=0.0, rng=random.Random(1))
+        self.assertEqual(result["action"], "approach")
+        self.assertFalse(result["explored"])
+
+    def test_choose_epsilon_seed(self):
+        t = self.table()
+        rng = random.Random(42)
+        explored = sum(1 for _ in range(1000) if pl.choose("expect|secure|day", t, epsilon=0.3, rng=rng)["explored"])
+        self.assertGreater(explored, 200)
+        self.assertLess(explored, 400)
+
+    def test_choose_unseen_q_zero(self):
+        result = pl.choose("loss|avoidant|night", {}, epsilon=0.0, rng=random.Random(2))
+        self.assertIn(result["action"], pl.ACTIONS)
+        self.assertEqual(result["q"], 0.0)
+
+    def test_policy_view_sorted(self):
+        rows = pl.policy_view(self.table(), "expect|secure|day")
+        self.assertEqual(len(rows), len(pl.ACTIONS))
+        self.assertEqual(rows[0]["action"], "approach")
+        self.assertGreaterEqual(rows[0]["q"], rows[-1]["q"])
+
+    def test_policy_view_unseen(self):
+        rows = pl.policy_view({}, "unknown")
+        self.assertEqual(len(rows), 6)
+        self.assertTrue(all(row["q"] == 0 for row in rows))
+
+    def test_context_buckets(self):
+        self.assertEqual(pl.hour_bucket(9), "day")
+        self.assertEqual(pl.hour_bucket(20), "evening")
+        self.assertEqual(pl.hour_bucket(2), "night")
+        self.assertIn("|", pl.make_context("protest", "anxious", 20))
+
+    def test_reward_slow_vs_fast(self):
+        self.assertAlmostEqual(pl.reward(True, 0.0, 0.0), 0.7, places=6)
+        self.assertAlmostEqual(pl.reward(True, 120.0, 0.0), 0.5, places=6)
+
+    def test_choice_after_history(self):
+        t = self.table()
+        first = pl.choose("expect|secure|day", t, epsilon=0.0, rng=random.Random(3))
+        second = pl.choose("expect|secure|day", t, epsilon=0.0, rng=random.Random(4))
+        self.assertEqual(first["action"], "approach")
+        self.assertEqual(second["action"], "approach")
+
+    def test_update_incremental_values(self):
+        t = pl.update({}, "c", "approach", 1.0, alpha=0.2)
+        self.assertAlmostEqual(t["c"]["approach"]["q"], 0.2, places=6)
+        t = pl.update(t, "c", "approach", 1.0, alpha=0.2)
+        self.assertAlmostEqual(t["c"]["approach"]["q"], 0.36, places=6)
+        self.assertEqual(t["c"]["approach"]["n"], 2)
+
+    def test_choose_same_seed_reproducible(self):
+        t = self.table()
+        first = [pl.choose("expect|secure|day", t, epsilon=0.5, rng=random.Random(11))
+                 for _ in range(20)]
+        second = [pl.choose("expect|secure|day", t, epsilon=0.5, rng=random.Random(11))
+                  for _ in range(20)]
+        self.assertEqual(first, second)
+
+    def test_reward_extremes(self):
+        self.assertAlmostEqual(pl.reward(True, 0.0, 1.0), 1.0, places=6)
+        self.assertAlmostEqual(pl.reward(False, 9999.0, -1.0), -0.3, places=6)
+
+    def test_make_context_hour_buckets_differ(self):
+        day = pl.make_context("expect", "secure", 9)
+        night = pl.make_context("expect", "secure", 2)
+        self.assertTrue(day.endswith("|day"))
+        self.assertTrue(night.endswith("|night"))
+        self.assertNotEqual(day, night)