#!/usr/bin/env python3 """test_send_wait_mac.py — 手教示の再生で, 送信のあとの 1.0 秒の待ちを daemon から Mac 側へ移し, その間も 電流の記録スレッドが角度を読む形 (依頼 213. 依頼 197 の案 2) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-15). python3 pi05/test_send_wait_mac.py # 全部 (再生を 2 回通すので 1 分半ほど) python3 pi05/test_send_wait_mac.py -v 偽の daemon は test_teach_current_actuals.PoseDaemon (read_servo の角度が腕の今の角度) で, send_angles だけ 本物の tools/pi/mecharm_daemon.py と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事. 確かめること: - --send-wait-on mac (既定): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから Mac 側で 1.0 秒待つ. この間に電流の記録スレッドが read_servo で読み, states.csv の actual 行になる - 到達の確かめ (本体の最初の get_angles) が始まる時刻は送信の始めから 1.0 秒 + 書き込みと読み 1 回 のあと (daemon で待つときと同じ. 縮んでいない) - 本体が daemon に送る命令 (関節の目標・速さ・爪) と順, 本体の読みの回数, 到達・再送・静止の確かめは daemon で 待つときと同じ (違うのは send_angles の wait だけ) - 送信と読みは同じ鍵で順に出る (送信の途中に read_servo が割り込まない. 鍵の中の時刻で重ならない) - 爪の命令から待ちの終わりまでは今までどおり読まない - --send-wait-on daemon は依頼 202 までと同じ (wait=1.0 を daemon へ. Mac 側で待たない. その間は読まない) - 区間と試行 JSON に send_wait_on・send_daemon_rtt_sec が残る. teach_state_rate.py が待ちの列を出す - _send_angles_guarded: 送信が例外でも 1.0 秒待ってから例外を返す・Ctrl-C は待たない・姿勢検査で弾いたら送らず待たない - コマンドの --send-wait-on の既定は mac・ほかの値は受け付けない - (codex R1) 窓の終わりぎわの read_servo が長引くと本体の次の読みはその分遅れる (早まらない・overruns に数える) - (codex R3) 送信が 4.0 秒で返らなければ切れて, 1.0 秒待ってから例外. 次の命令はつなぎ直して通る KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ). """ import io import sys import tempfile import threading import time import unittest from pathlib import Path from unittest import mock _HERE = Path(__file__).resolve().parent sys.path.insert(0, str(_HERE)) sys.path.insert(0, str(_HERE.parent / "dynamic_tracking_limits" / "drag_teaching")) import test_teach_currents as ttc # noqa: E402 import test_recorder_currents as trc # noqa: E402 import test_teach_current_actuals as tca # noqa: E402 (PoseDaemon・write_states) import policy_recorder as pr # noqa: E402 import visual_servo_pick as vsp # noqa: E402 import record_teach_demo as rtd # noqa: E402 import teach_state_rate as tsr # noqa: E402 WRITE_SEC = 0.010 # 本物の _mc.send_angles() の書き込み (実測 約 10 ms) READ_ONCE_SEC = trc.OVERHEAD_SEC + trc.ANGLES_SEC # 送ったあとの read_angles_once_for_log 1 回 class WaitDaemon(tca.PoseDaemon): """send_angles を本物の daemon と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事.""" def _handle(self, c): if c.get("cmd") != "send_angles": return super()._handle(c) t0 = time.time() self.cmds.append(c) n = self.n_send self.n_send += 1 time.sleep(WRITE_SEC) if n not in self.ignore_sends: start, goal = self.pose(), [float(x) for x in c["angles"]] self.cur = goal self.move = (start, goal, time.time(), max(abs(x - y) for x, y in zip(start, goal)) / ttc.ARM_DEG_PER_SEC) wait = float(c.get("wait", 0)) if wait > 0: time.sleep(wait) time.sleep(READ_ONCE_SEC) with self.span_lock: self.spans.append(("send_angles", t0, time.time(), dict(c))) return {"ok": True, "result": 1, "elapsed_ms": WRITE_SEC * 1000.0} def replay(mode, run_dir, ignore_sends=()): """cmd_run と同じ順で再生を 1 回通す. 戻り値: dict (result・通知・log_record・daemon・鍵の中の時刻).""" d = WaitDaemon(ignore_sends=ignore_sends) rpcs = [] def obs(cmd_obj, resp, t0, t1, err): rpcs.append(((cmd_obj or {}).get("cmd"), t0, t1, threading.current_thread().name)) pr.add_rpc_observer(obs) try: result, sent, log_record, recorder = tca.replay(d, run_dir, sink=True, send_wait_on=mode) finally: pr.remove_rpc_observer(obs) d.close() return {"result": result, "sent": sent, "lr": log_record, "rec": recorder, "d": d, "rpcs": rpcs} def sends(d): return [s for s in d.spans if s[0] == "send_angles"] def next_main_get(d, after): """after より後で最初の本体の get_angles の始め (記録スレッドは get_angles を使わない).""" return min(s[1] for s in d.spans if s[0] == "get_angles" and s[1] >= after) class TestReplaySendWait(unittest.TestCase): """再生を 2 回 (mac / daemon. どちらも電流を記録し角度を states.csv に渡す) 通して比べる.""" @classmethod def setUpClass(cls): cls.td = Path(tempfile.mkdtemp()) pr.install_daemon_lock() cls.mac = replay("mac", cls.td / "run_0001_20991115_000001") cls.dmn = replay("daemon", cls.td / "run_0002_20991115_000002") root = cls.td / "states" cls.st_mac = tca.write_states(root, "run_0001_20991115_000001", cls.mac["sent"]) cls.st_dmn = tca.write_states(root, "run_0002_20991115_000002", cls.dmn["sent"]) def test_completed(self): self.assertEqual((self.mac["result"], self.dmn["result"]), ("completed", "completed")) def test_wait_sent_to_daemon(self): """mac は wait=0, daemon は wait=1.0 を送る. ほかの中身 (目標・速さ) と順は同じ.""" wm = {s[3].get("wait") for s in sends(self.mac["d"])} wd = {s[3].get("wait") for s in sends(self.dmn["d"])} self.assertEqual((wm, wd), ({0}, {rtd.SEND_WAIT_SEC})) strip = lambda d: [(s[0], {k: v for k, v in s[3].items() if k != "wait"}) # noqa: E731 for s in d.spans if s[0] in ("send_angles", "set_gripper", "set_gripper_value", "set_fresh_mode")] self.assertEqual(strip(self.mac["d"]), strip(self.dmn["d"])) def test_socket_timeout_kept(self): """mac の wait=0 でもソケットの期限は daemon で待つときと同じ 4.0 秒 (既定の 35 秒にしない).""" seen = [] orig = vsp._daemon_request def spy(cmd_obj, timeout_override=None, **k): seen.append((cmd_obj.get("wait"), timeout_override)) return {"ok": True, "elapsed_ms": 1.0} with mock.patch.object(vsp, "_daemon_request", spy), mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), \ mock.patch.object(rtd.time, "sleep", lambda s: None): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") self.assertIs(vsp._daemon_request, orig) self.assertEqual(seen, [(0, rtd.SEND_WAIT_SEC + 3.0)]) def test_arrival_start_not_earlier(self): """本体の到達の確かめが始まるのは, どちらも送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと.""" lo = rtd.SEND_WAIT_SEC + WRITE_SEC + READ_ONCE_SEC delays = {} for name, r in (("mac", self.mac), ("daemon", self.dmn)): ds = [] for s in sends(r["d"]): ds.append(next_main_get(r["d"], s[2]) - s[1]) delays[name] = ds self.assertGreaterEqual(min(ds), lo - 0.002, name) # mac は daemon と同じ (送信の返事を待つ時間と, 眠りの終わりから起きるまでの時間の分だけずれる) for m, d in zip(delays["mac"], delays["daemon"]): self.assertLess(abs(m - d), 0.08) print(f"\n送信の始め → 到達の確かめの始め (秒): mac {[round(x, 3) for x in delays['mac']]}" f" / daemon {[round(x, 3) for x in delays['daemon']]}") def test_mac_reads_during_wait(self): """mac: 送信の返事のあとの 1.0 秒に read_servo が入る. daemon: 送信の間に read_servo は入らない.""" per = [] for s in sends(self.mac["d"]): end = s[2] n = sum(1 for x in self.mac["d"].spans if x[0] == "read_servo" and end <= x[1] and x[2] <= end + rtd.SEND_WAIT_SEC + 0.05) per.append(n) self.assertTrue(all(n >= 5 for n in per), per) for s in sends(self.dmn["d"]): inside = [x for x in self.dmn["d"].spans if x[0] == "read_servo" and s[1] <= x[1] < s[2]] self.assertEqual(inside, []) rs = sorted(x[2] - x[1] for x in self.mac["d"].spans if x[0] == "read_servo") print(f"\n送信のあとの 1.0 秒に読めた read_servo の回数 (偽の daemon. 1 回 中央値 {rs[len(rs) // 2] * 1000:.0f} ms):" f" {per} 中央値 {sorted(per)[len(per) // 2]}") def test_lock_serializes_send_and_read(self): """送信と read_servo は同じ鍵の中で 1 件ずつ (鍵の中の時刻が重ならない). daemon 側の時刻でも重ならない.""" for r in (self.mac, self.dmn): ivs = sorted((t0, t1, c) for c, t0, t1, _ in r["rpcs"] if c in ("send_angles", "read_servo", "get_angles")) self.assertGreater(len(ivs), 50) for (a0, a1, ca), (b0, b1, cb) in zip(ivs, ivs[1:]): self.assertLessEqual(a1, b0 + 1e-6, f"{ca} と {cb} が重なる") threads = {(c, th) for c, _, _, th in r["rpcs"] if c == "read_servo"} self.assertTrue(threads and all(th == "record_currents" for _, th in threads)) sp = sorted(r["d"].spans, key=lambda s: s[1]) for a, b in zip(sp, sp[1:]): self.assertLessEqual(a[2], b[1] + 1e-6) def test_main_unchanged(self): """本体の読みの回数・到達と静止の確かめの結果・本体の通知の並びは daemon で待つときと同じ.""" n_get = lambda r: sum(1 for s in r["d"].spans if s[0] == "get_angles") # noqa: E731 # 到達の確かめの回数は腕が着くまでの実時間で決まるので, 別々に流した 2 回の再生では混んだ Mac で 1 回ずれる # ことがある (test_teach_current_actuals の daemon どうしでも起きた). 読み方は同じなので差は 1 回までとする self.assertLessEqual(abs(n_get(self.mac) - n_get(self.dmn)), 1) def summary(lr): return [(g.get("kind"), g.get("arrival_ok"), g.get("retried"), tuple(g.get("warnings") or ()), (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads")) for g in lr["segments"]] self.assertEqual(summary(self.mac["lr"]), summary(self.dmn["lr"])) no_act = lambda r: [k for k in tca.main_kinds(r["sent"]) if k[0] != "actual"] # noqa: E731 self.assertEqual(no_act(self.mac), no_act(self.dmn)) # stage・爪の通知の並びと中身は同じ n_act = lambda r: sum(1 for k in tca.main_kinds(r["sent"]) if k[0] == "actual") # noqa: E731 self.assertLessEqual(abs(n_act(self.mac) - n_act(self.dmn)), 1) # 本体の actual (= 本体の読み) は上と同じ扱い self.assertEqual(self.mac["lr"]["currents"]["overruns"], 0) def test_no_reads_during_gripper(self): for r in (self.mac, self.dmn): for cmd, g0, nxt in ttc.gripper_windows(r["d"].spans): inside = [x for x in r["d"].spans if x[0] == "read_servo" and g0 <= x[1] < nxt - 0.03] self.assertEqual(inside, [], f"{cmd} の待ちの間に read_servo") def test_segment_records(self): for r, mode in ((self.mac, "mac"), (self.dmn, "daemon")): moves = [g for g in r["lr"]["segments"] if g.get("kind") == "move" or "send_rtt_sec" in g] self.assertGreater(len(moves), 3) for g in moves: self.assertEqual(g["send_wait_on"], mode) self.assertIsNotNone(g["send_daemon_rtt_sec"]) # send_rtt_sec はどちらでも 1.0 秒の待ちを含む self.assertGreaterEqual(g["send_rtt_sec"], rtd.SEND_WAIT_SEC) if mode == "mac": self.assertLess(g["send_daemon_rtt_sec"], 0.5) else: self.assertGreaterEqual(g["send_daemon_rtt_sec"], rtd.SEND_WAIT_SEC) def test_rate_table(self): """teach_state_rate.py: mac は送信の間の抜けが埋まり 1 秒超の抜けが減る. 待ちの列は試行 JSON から読む.""" m_mac, segs = tsr.measure(self.st_mac.parent.parent) m_dmn, _ = tsr.measure(self.st_dmn.parent.parent) self.assertEqual(m_mac["order_reversed"], 0) self.assertLess(m_mac["all_long_n"], m_dmn["all_long_n"]) self.assertLess(m_mac["all_p90"], m_dmn["all_p90"]) self.assertGreater(m_mac["n_current_thread"], m_dmn["n_current_thread"]) print(f"\n偽の daemon での actual の間: daemon で待つ 中央値 {m_dmn['all_median']:.3f} 90% {m_dmn['all_p90']:.3f}" f" 1秒超 {m_dmn['all_long_n']} / mac で待つ 中央値 {m_mac['all_median']:.3f} 90% {m_mac['all_p90']:.3f}" f" 1秒超 {m_mac['all_long_n']} (電流スレッドの行 {m_dmn['n_current_thread']} → {m_mac['n_current_thread']})") def test_rate_table_send_wait_column(self): td = Path(tempfile.mkdtemp()) run = td / "run_0009_20991115_000009" (run / "recording").mkdir(parents=True) (run / "recording" / "states.csv").write_text(self.st_mac.read_text()) import json (run / f"{run.name}.json").write_text(json.dumps({"send_wait_on": "mac", "segments": [ {"step": 1, "kind": "move", "to_name": "HOME", "send_rtt_sec": 1.05, "send_daemon_rtt_sec": 0.03}]})) m, segs = tsr.measure(run) self.assertEqual(m["send_wait_on"], "mac") self.assertEqual(segs[0]["send_daemon_rtt_sec"], 0.03) with mock.patch("sys.stdout", new=io.StringIO()) as out: tsr.print_group("後", [m]) tsr.print_segments([("後", segs)]) self.assertIn("待ち", out.getvalue()) self.assertIn("daemon 0.030", out.getvalue()) class TestSendRetry(unittest.TestCase): """送信無視 → 5 秒待って再送の経路も mac で通る (再送も Mac 側で 1.0 秒待つ).""" def test_retry_path(self): pr.install_daemon_lock() r = replay("mac", Path(tempfile.mkdtemp()) / "run_0003_20991115_000003", ignore_sends=(1,)) self.assertEqual(r["result"], "completed") seg = [g for g in r["lr"]["segments"] if g.get("retried")] self.assertEqual(len(seg), 1) self.assertIsNotNone(seg[0]["send_daemon_rtt_retry_sec"]) self.assertGreaterEqual(seg[0]["send_rtt_retry_sec"], rtd.SEND_WAIT_SEC) self.assertEqual({s[3].get("wait") for s in sends(r["d"])}, {0}) class SlowTailDaemon(WaitDaemon): """送信の返事から slow_after 秒より後に始まる read_servo を slow_sec 秒遅らせる (窓の終わりぎわの読みが長引く場合).""" def __init__(self, slow_after=0.7, slow_sec=0.5, send_extra=0.0): self.slow_after, self.slow_sec, self.send_extra = slow_after, slow_sec, send_extra self.send_end = None super().__init__() def _handle(self, c): if c.get("cmd") == "send_angles": time.sleep(self.send_extra) resp = super()._handle(c) self.send_end = time.time() return resp if c.get("cmd") == "read_servo" and self.send_end and time.time() - self.send_end > self.slow_after: time.sleep(self.slow_sec) return super()._handle(c) class TestSlowAndTimeout(unittest.TestCase): """codex R1・R3: 窓の終わりで読みが長引いた場合と, 送信のソケットの期限切れを本物の通信 (127.0.0.1) で通す.""" def _with_daemon(self, d, fn): vsp.close_daemon_socket() try: with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", d.port), \ mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), mock.patch("sys.stdout", new=io.StringIO()): return fn() finally: vsp.close_daemon_socket() d.close() def test_slow_read_at_window_end(self): """窓の終わりぎわに始めた read_servo が 0.5 秒長引くと, 本体の次の読みはその分だけ遅れる (早まらない). 遅れは read_servo 1 回の上限 (READ_SERVO_TIMEOUT_SEC) までで, overruns に数える. 1.0 秒の待ちそのものは縮まない. 読み方 (依頼 121 の窓の決まり) は変えていないので, 0.3 秒の到達の確かめの合間でも前から同じことが起こりうる.""" pr.install_daemon_lock() d = SlowTailDaemon(slow_after=0.7, slow_sec=0.5) td = Path(tempfile.mkdtemp()) def go(): rec = rtd._Recorder(False, "run_s") rec.currents = rtd._start_currents(td) time.sleep(0.2) t0 = time.time() rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec) t_back = time.time() vsp.daemon_get_angles() meta = rec.currents.stop() rtd._ACTIVE_CURRENTS.remove(rec.currents) return t0, t_back, meta t0, t_back, meta = self._with_daemon(d, go) get0 = next_main_get(d, t0) self.assertGreaterEqual(t_back - t0, rtd.SEND_WAIT_SEC) # Mac 側の待ちは縮まない self.assertGreaterEqual(get0 - t0, rtd.SEND_WAIT_SEC + WRITE_SEC) # 次の読みは早まらない self.assertGreaterEqual(meta["overruns"], 1) # 見込み超えとして数える self.assertLess(get0 - t0, rtd.SEND_WAIT_SEC + 0.1 + pr.READ_SERVO_TIMEOUT_SEC) print(f"\n窓の終わりで read_servo が 0.5 秒長引いた場合: 送信の始め → 本体の次の読み {get0 - t0:.3f} 秒" f" (長引かなければ 約 {rtd.SEND_WAIT_SEC + WRITE_SEC + READ_ONCE_SEC:.3f} 秒) overruns {meta['overruns']}") def test_send_socket_timeout(self): """daemon が 4.0 秒より長く返さなければ, 4.0 秒で切れて例外. そのあとも 1.0 秒待ってから例外を返す. 次の命令はつなぎ直して通る.""" d = SlowTailDaemon(send_extra=rtd.SEND_SOCKET_TIMEOUT_SEC + 0.6) def go(): t0 = time.monotonic() with self.assertRaises(Exception): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") el = time.monotonic() - t0 rtt = rtd._LAST_SEND["daemon_rtt_sec"] time.sleep(1.0) # 偽の daemon が遅れた返事を書き終えるまで a = vsp.daemon_get_angles() return el, rtt, a el, rtt, a = self._with_daemon(d, go) self.assertAlmostEqual(rtt, rtd.SEND_SOCKET_TIMEOUT_SEC, delta=0.3) self.assertGreaterEqual(el, rtd.SEND_SOCKET_TIMEOUT_SEC + rtd.SEND_WAIT_SEC - 0.05) self.assertLess(el, rtd.SEND_SOCKET_TIMEOUT_SEC + rtd.SEND_WAIT_SEC + 0.5) self.assertEqual(len(a), 6) class _Rec(object): def __init__(self): self.windows = [] def currents_window(self, sec): self.windows.append(sec) class TestGuardedUnits(unittest.TestCase): def setUp(self): self.calls = [] self.slept = [] self.p = [mock.patch.object(rtd.time, "sleep", lambda s: self.slept.append(s)), mock.patch.object(rtd, "daemon_send_angles", self._send)] for p in self.p: p.start() self.exc = None def tearDown(self): for p in self.p: p.stop() def _send(self, pose, speed, wait=0, timeout_override=None): self.calls.append((list(pose), speed, wait, timeout_override, list(self.slept))) if self.exc is not None: raise self.exc return {"ok": True} def test_mac_waits_after_send(self): rec = _Rec() with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec) self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, 0, rtd.SEND_SOCKET_TIMEOUT_SEC, [])]) # 送る前は眠らない self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC]) # 送ったあとに 1.0 秒 (縮めない) self.assertEqual(rec.windows, [rtd.SEND_WAIT_SEC]) # その間を電流の記録に知らせる self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"]) def test_mac_without_recorder(self): with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC]) def test_daemon_mode_unchanged(self): rec = _Rec() with mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec) self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, rtd.SEND_WAIT_SEC, None, [])]) self.assertEqual((self.slept, rec.windows), ([], [])) def test_mac_send_error_still_waits(self): self.exc = RuntimeError("socket timeout") rec = _Rec() with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(RuntimeError): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec) self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC]) self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"]) def test_daemon_send_error_keeps_rtt(self): self.exc = RuntimeError("socket timeout") with mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"), self.assertRaises(RuntimeError): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec()) self.assertEqual(self.slept, []) self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"]) def test_mac_ctrl_c_not_waited(self): self.exc = KeyboardInterrupt() with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(KeyboardInterrupt): rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec()) self.assertEqual(self.slept, []) def test_backstop_no_send_no_wait(self): bad = list(rtd.HOME_ANGLES) bad[0] = float("nan") with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(rtd._Aborted): rtd._send_angles_guarded(bad, 20, "t", recorder=_Rec()) self.assertEqual((self.calls, self.slept), ([], [])) self.assertIsNone(rtd._LAST_SEND["daemon_rtt_sec"]) class TestCli(unittest.TestCase): def _parse(self, argv): got = {} with mock.patch.object(rtd, "cmd_run", lambda a: got.setdefault("a", a) and 0), \ mock.patch.object(sys, "argv", ["record_teach_demo.py"] + argv): rtd.main() return got["a"] def test_default_mac(self): self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "mac") self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "daemon"]).send_wait_on, "daemon") def test_bad_value(self): with mock.patch("sys.stderr", new=io.StringIO()), self.assertRaises(SystemExit): self._parse(["run", "--teach", "x.json", "--send-wait-on", "pi"]) def test_trial_json_has_send_wait_on(self): """cmd_run の試行 JSON (log_record) と params に send_wait_on を入れている (cmd_run を最後まで通すには カメラと Pi が要るので, ソースで確かめる).""" import inspect src = inspect.getsource(rtd.cmd_run) head = src[src.index("log_record = {"):] self.assertIn('"send_wait_on": SEND_WAIT_ON,', head[:head.index('"current_angles_before_replay"')]) self.assertEqual(src.count('"send_wait_on": SEND_WAIT_ON'), 2) # いちばん上と params def test_cmd_run_rejects_bad_value(self): """cmd_run を直接呼ぶ形でも mac / daemon 以外は止める (グローバルは変えない).""" a = mock.Mock(grip_value=None, power=None, send_wait_on="pi", no_currents=False, no_record=False) with mock.patch("sys.stdout", new=io.StringIO()), self.assertRaises(SystemExit): rtd.cmd_run(a) self.assertEqual(rtd.SEND_WAIT_ON, "mac") if __name__ == "__main__": unittest.main()