fix(kvb-org-organize): move the council root out of /tmp with a lossless migration
councilroot.py resolves one durable council root for every script and migrates the old /tmp root under the held locks: a preflight conflict moves nothing, each legacy file is renamed to a staging name before it is copied so a late writer is merged by the catch-up, id-less journals merge by line multiset, a differing whole file is kept beside its namesake, and a crash marker makes install copy the skills and report. One settings-file list, managed drop-ins included, serves councilroot.py and queue.py. Tests run once on unify/skills-20261114 after the merge (operator order 2026-11-14). 🎯 Fix: 88 % 💥 Break: 7 % 💸 Tokens: 100 % ⏱️ Velocity: 100 % 🛡️ Security: 100 % 🏆 Score: 82 🚦 Gate: ⛔ fix 88 % < 90, break 7 % > 5 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
699f3227c9
commit
8726ed37a7
47 files changed
+2199
-191
No files matched your search
@@ -0,0 +1,872 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import errno
|
||||
import fcntl
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from types import ModuleType
|
||||
from unittest import mock
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
ORGANIZE = REPO_ROOT / "skills" / "kvb-org-organize" / "scripts"
|
||||
COUNCIL_ROOT = ORGANIZE / "councilroot.py"
|
||||
WATCH = ORGANIZE / "watch.py"
|
||||
QUEUE = REPO_ROOT / "skills" / "kvb-org-queue" / "scripts" / "queue.py"
|
||||
SECURITY = REPO_ROOT / "skills" / "kvb-check-security" / "scripts" / "security.py"
|
||||
GATES = REPO_ROOT / "skills" / "kvb-check-gate" / "scripts" / "gates.py"
|
||||
LOG = REPO_ROOT / "skills" / "kvb-org-perform" / "scripts" / "log.py"
|
||||
CLIENT = REPO_ROOT / "orchestrator" / "client"
|
||||
INSTALL = REPO_ROOT / "scripts" / "install.sh"
|
||||
GATE_SKILL = REPO_ROOT / "skills" / "kvb-check-gate"
|
||||
SCANNED = ("skills", "orchestrator", "scripts")
|
||||
FORBIDDEN = re.compile(r"/tmp/(?:agents-council|kvb-git-diff|kvb-orchestrator-approvals|release-)")
|
||||
LEGACY_LINE = 'LEGACY = Path("/tmp/agents-council")'
|
||||
DIR_SLASH = re.compile(r"councilroot\.py dir [^)\n]*\)/")
|
||||
RADIO = REPO_ROOT / "skills" / "kvb-org-radio" / "scripts" / "radio.py"
|
||||
CLEANUP_SERVICE = REPO_ROOT / "skills" / "kvb-org-queue-cleanup" / "systemd" / "kvb-org-queue-cleanup.service"
|
||||
|
||||
|
||||
def load(path: Path, name: str) -> ModuleType:
|
||||
spec = importlib.util.spec_from_file_location(name, path)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
def rows(path: Path) -> list[str]:
|
||||
return [json.loads(line)["id"] for line in path.read_text(encoding="utf-8").splitlines()]
|
||||
|
||||
|
||||
class Home(unittest.TestCase):
|
||||
def setUp(self):
|
||||
tmp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(tmp.cleanup)
|
||||
self.base = Path(tmp.name).resolve()
|
||||
self.home = self.base / "home"
|
||||
self.home.mkdir()
|
||||
patch = mock.patch.dict(os.environ, {"HOME": str(self.home)})
|
||||
patch.start()
|
||||
self.addCleanup(patch.stop)
|
||||
for name in ("AGENTS_COUNCIL_ROOT", "XDG_STATE_HOME"):
|
||||
os.environ.pop(name, None)
|
||||
self.durable = self.home / ".local" / "state" / "agents-council"
|
||||
self.shared = self.home / ".local" / "state" / "agents-shared"
|
||||
self.councilroot = load(COUNCIL_ROOT, f"test_councilroot_{id(self)}")
|
||||
|
||||
def cli(self, *args: str, **env: str) -> subprocess.CompletedProcess:
|
||||
return subprocess.run(
|
||||
[sys.executable, str(COUNCIL_ROOT), *args], env={"PATH": os.environ["PATH"], "HOME": str(self.home), **env},
|
||||
capture_output=True, text=True, check=False,
|
||||
)
|
||||
|
||||
|
||||
class TestResolver(Home):
|
||||
def test_agents_share_one_root_and_the_host_keeps_another_by_default(self):
|
||||
self.assertEqual((self.councilroot.root(), self.councilroot.durable()), (self.shared, self.durable))
|
||||
self.assertNotEqual(self.councilroot.root(), self.councilroot.durable())
|
||||
|
||||
def test_xdg_state_home_moves_both_roots_only_when_absolute(self):
|
||||
for value, state in (("/srv/state", Path("/srv/state")), ("relative", self.durable.parent), ("", self.durable.parent)):
|
||||
with self.subTest(value=value), mock.patch.dict(os.environ, {"XDG_STATE_HOME": value}):
|
||||
self.assertEqual((self.councilroot.root(), self.councilroot.durable()),
|
||||
(state / "agents-shared", state / "agents-council"))
|
||||
|
||||
def test_agents_council_root_wins_and_an_empty_or_relative_one_means_unset(self):
|
||||
with mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": "/srv/council", "XDG_STATE_HOME": "/srv/state"}):
|
||||
self.assertEqual((self.councilroot.root(), self.councilroot.durable()), (Path("/srv/council"), Path("/srv/state/agents-council")))
|
||||
for value in ("", "relative-council"):
|
||||
with self.subTest(value=value), mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": value}):
|
||||
self.assertEqual(self.councilroot.root(), self.shared)
|
||||
|
||||
def test_the_cli_prints_the_roots_and_creates_private_parts(self):
|
||||
self.assertEqual(self.cli("root").stdout, f"{self.shared}\n")
|
||||
self.assertEqual(self.cli("root", AGENTS_COUNCIL_ROOT=str(self.base / "c")).stdout, f"{self.base / 'c'}\n")
|
||||
self.assertEqual(self.cli("durable", AGENTS_COUNCIL_ROOT=str(self.base / "c")).stdout, f"{self.durable}\n")
|
||||
for args, made in ((("dir", "gates"), self.shared / "gates"), (("release", "1.2.3"), self.durable.parent / "agents-release" / "1.2.3")):
|
||||
with self.subTest(args=args):
|
||||
done = self.cli(*args)
|
||||
self.assertEqual((done.returncode, done.stdout), (0, f"{made}\n"), done.stderr)
|
||||
self.assertEqual(made.stat().st_mode & 0o777, 0o700)
|
||||
self.assertEqual(self.shared.stat().st_mode & 0o777, 0o700)
|
||||
self.assertFalse(self.durable.exists())
|
||||
refused = self.cli("dir", "../escape")
|
||||
self.assertEqual((refused.returncode, refused.stderr), (2, "councilroot: not a directory name: '../escape'\n"))
|
||||
self.assertFalse((self.shared.parent / "escape").exists())
|
||||
|
||||
def test_a_root_the_sandbox_cannot_create_turns_the_hooks_off_with_the_reason(self):
|
||||
state = self.base / "frozen"
|
||||
state.mkdir(mode=0o500)
|
||||
self.addCleanup(state.chmod, 0o700)
|
||||
with mock.patch.dict(os.environ, {"XDG_STATE_HOME": str(state)}):
|
||||
watch = load(WATCH, f"test_council_root_frozen_{id(self)}")
|
||||
out = io.StringIO()
|
||||
with contextlib.redirect_stdout(out):
|
||||
self.assertEqual(watch.guard_root(hook=True), 0)
|
||||
self.assertIn(f"cannot create {state / 'agents-shared'}", out.getvalue())
|
||||
|
||||
def test_a_part_the_cli_cannot_create_exits_2_naming_why_and_prints_nothing(self):
|
||||
state = self.base / "frozen"
|
||||
state.mkdir(mode=0o500)
|
||||
self.addCleanup(state.chmod, 0o700)
|
||||
done = self.cli("dir", "gates", "slug", XDG_STATE_HOME=str(state))
|
||||
self.assertEqual((done.returncode, done.stdout), (2, ""))
|
||||
self.assertTrue(done.stderr.startswith("councilroot: ") and "Permission denied" in done.stderr and "Traceback" not in done.stderr, done.stderr)
|
||||
|
||||
|
||||
class TestMigrate(Home):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.legacy = self.base / "legacy"
|
||||
self.legacy.mkdir(mode=0o700)
|
||||
self.target = self.base / "state" / "agents-shared"
|
||||
|
||||
def write(self, path: Path, text: str, mtime: int | None = None) -> Path:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(text, encoding="utf-8")
|
||||
path.chmod(0o600)
|
||||
if mtime is not None:
|
||||
os.utime(path, (mtime, mtime))
|
||||
return path
|
||||
|
||||
def migrate(self) -> list[str]:
|
||||
return self.councilroot.migrate(self.legacy, self.target)
|
||||
|
||||
def test_every_file_moves_and_a_second_run_moves_nothing(self):
|
||||
self.write(self.legacy / "rasci.json", "{}\n", 1000)
|
||||
self.write(self.legacy / "work" / "a" / "claim.json", '{"session": "s1"}\n')
|
||||
self.write(self.legacy / "holds" / "1-2.lock", "")
|
||||
self.assertEqual(self.migrate(), [f"moved 3 files from {self.legacy} to {self.target}"])
|
||||
self.assertEqual((self.target / "rasci.json").read_text(encoding="utf-8"), "{}\n")
|
||||
self.assertEqual((self.target / "rasci.json").stat().st_mtime, 1000)
|
||||
self.assertEqual((self.target / "rasci.json").stat().st_mode & 0o777, 0o600)
|
||||
self.assertEqual((self.target / "work" / "a" / "claim.json").read_text(encoding="utf-8"), '{"session": "s1"}\n')
|
||||
self.assertTrue((self.target / "holds" / "1-2.lock").is_file())
|
||||
self.assertFalse(self.legacy.exists())
|
||||
self.assertEqual(sorted(path.name for path in self.target.iterdir()), ["holds", "rasci.json", "work"])
|
||||
self.assertEqual(self.migrate(), [])
|
||||
|
||||
def test_a_differing_whole_file_refuses_the_move_and_a_catch_up_keeps_it_beside(self):
|
||||
newer = self.write(self.target / "rasci.json", "durable\n", 2000)
|
||||
self.write(self.legacy / "rasci.json", "legacy\n", 1000)
|
||||
self.write(self.legacy / "queue.json", '{"seq": 1, "entries": []}\n')
|
||||
line = f"conflict {newer} differs from {self.legacy / 'rasci.json'}"
|
||||
with self.assertRaises(self.councilroot.Blocked) as blocked:
|
||||
self.migrate()
|
||||
self.assertEqual(blocked.exception.lines, [line])
|
||||
done = self.cli("migrate", "--legacy", str(self.legacy), AGENTS_COUNCIL_ROOT=str(self.target))
|
||||
self.assertEqual((done.returncode, done.stdout), (4, f"{line}\nnothing moved from {self.legacy}\n"), done.stderr)
|
||||
self.assertEqual(sorted(path.name for path in self.legacy.iterdir()), ["queue.json", "rasci.json"])
|
||||
self.assertFalse((self.target / "queue.json").exists())
|
||||
kept = self.target / f"rasci.json.legacy-{hashlib.sha256(b"legacy\n").hexdigest()[:12]}"
|
||||
for run in (1, 2):
|
||||
with self.subTest(run=run):
|
||||
if run == 2:
|
||||
self.write(self.legacy / "rasci.json", "legacy\n")
|
||||
caught = self.cli("migrate", "--legacy", str(self.legacy), "--catch-up", AGENTS_COUNCIL_ROOT=str(self.target))
|
||||
self.assertEqual(caught.returncode, 3, caught.stderr)
|
||||
self.assertIn(f"kept {self.legacy / 'rasci.json'} beside {newer} as {kept}", caught.stdout)
|
||||
self.assertEqual((newer.read_text(encoding="utf-8"), kept.read_text(encoding="utf-8")), ("durable\n", "legacy\n"))
|
||||
self.assertFalse(self.legacy.exists())
|
||||
self.assertEqual(sorted(path.name for path in self.target.iterdir()), ["queue.json", "rasci.json", kept.name])
|
||||
|
||||
def test_a_file_it_cannot_move_refuses_the_whole_move_and_preflight_predicts_it(self):
|
||||
self.write(self.legacy / "rasci.json", '{"work/x": {}}\n')
|
||||
self.write(self.legacy / "queue.json", '{"seq": 9, "entries": []}\n')
|
||||
source = self.write(self.legacy / "late.json", "{}\n")
|
||||
os.link(source, self.base / "second-link")
|
||||
done = self.cli("migrate", "--legacy", str(self.legacy), AGENTS_COUNCIL_ROOT=str(self.target))
|
||||
line = f"unmoved {source}: not a regular file with a single link"
|
||||
self.assertEqual((done.returncode, done.stdout), (4, f"{line}\nnothing moved from {self.legacy}\n"), done.stderr)
|
||||
self.assertEqual(sorted(path.name for path in self.legacy.iterdir()), ["late.json", "queue.json", "rasci.json"])
|
||||
self.assertFalse(self.target.exists() and any(self.target.iterdir()))
|
||||
checked = self.cli("preflight", "--legacy", str(self.legacy), "--managed", str(self.base / "no-managed"), AGENTS_COUNCIL_ROOT=str(self.target))
|
||||
self.assertEqual(checked.returncode, 2)
|
||||
self.assertIn(line, checked.stderr)
|
||||
|
||||
def test_a_move_failing_after_the_check_leaves_a_partial_state_with_exit_5(self):
|
||||
self.write(self.legacy / "rasci.json", "{}\n")
|
||||
late = self.write(self.legacy / "late.json", "{}\n")
|
||||
real = self.councilroot.copied
|
||||
|
||||
def racing(helper, legacy, source, *rest):
|
||||
if source.name.startswith(late.name):
|
||||
raise OSError(errno.EBUSY, "raced", str(source))
|
||||
return real(helper, legacy, source, *rest)
|
||||
|
||||
out = io.StringIO()
|
||||
with mock.patch.object(self.councilroot, "copied", racing), mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": str(self.target)}), contextlib.redirect_stdout(out):
|
||||
code = self.councilroot.main(["migrate", "--legacy", str(self.legacy)])
|
||||
self.assertEqual(code, 5)
|
||||
self.assertTrue(any(line.startswith(f"unmoved {late}") and line.endswith(": raced") for line in out.getvalue().splitlines()), out.getvalue())
|
||||
self.assertTrue((self.target / "rasci.json").is_file())
|
||||
self.assertEqual([path.name.startswith("late.json") for path in self.legacy.iterdir()], [True])
|
||||
|
||||
def test_a_row_appended_while_its_journal_moves_reaches_the_root_through_the_catch_up(self):
|
||||
journal = self.write(self.legacy / "scores.jsonl", '{"time": 1, "digest": "a"}\n')
|
||||
late = '{"time": 2, "digest": "written between the copy and the unlink"}\n'
|
||||
real = self.councilroot.copied
|
||||
|
||||
def racing(helper, legacy, source, *rest):
|
||||
done = real(helper, legacy, source, *rest)
|
||||
with open(journal, "a", encoding="utf-8") as writer:
|
||||
writer.write(late)
|
||||
return done
|
||||
|
||||
with mock.patch.object(self.councilroot, "copied", racing):
|
||||
self.migrate()
|
||||
self.councilroot.migrate(self.legacy, self.target, True)
|
||||
self.assertEqual((self.target / "scores.jsonl").read_text(encoding="utf-8"), '{"time": 1, "digest": "a"}\n' + late)
|
||||
self.assertFalse(self.legacy.exists())
|
||||
|
||||
def test_a_crash_mid_move_leaves_the_started_marker_until_a_run_completes_the_move(self):
|
||||
self.write(self.legacy / "a.json", "{}\n")
|
||||
self.write(self.legacy / "b.json", '{"b": 1}\n')
|
||||
real = self.councilroot.copied
|
||||
|
||||
def crashing(helper, legacy, source, *rest):
|
||||
if source.name.startswith("b.json"):
|
||||
raise RuntimeError("boom")
|
||||
return real(helper, legacy, source, *rest)
|
||||
|
||||
marker = self.durable / "migrate.started"
|
||||
with mock.patch.object(self.councilroot, "copied", crashing), self.assertRaises(RuntimeError):
|
||||
self.migrate()
|
||||
self.assertTrue(marker.is_file() and (self.target / "a.json").is_file())
|
||||
self.assertEqual(self.migrate(), [f"moved 1 files from {self.legacy} to {self.target}"])
|
||||
self.assertEqual((self.target / "b.json").read_text(encoding="utf-8"), '{"b": 1}\n')
|
||||
self.assertFalse(marker.exists() or self.legacy.exists())
|
||||
|
||||
def test_identical_copies_are_one_and_leave_the_legacy_root(self):
|
||||
same = self.write(self.target / "rasci.json", "{}\n", 2000)
|
||||
self.write(self.legacy / "rasci.json", "{}\n", 1000)
|
||||
self.assertEqual(self.migrate(), [f"moved 1 files from {self.legacy} to {self.target}"])
|
||||
self.assertEqual((same.read_text(encoding="utf-8"), same.stat().st_mtime), ("{}\n", 2000))
|
||||
self.assertFalse(self.legacy.exists())
|
||||
|
||||
def test_a_held_lock_or_a_queued_job_refuses_the_whole_move(self):
|
||||
hold = self.write(self.legacy / "holds" / "1-2.lock", "")
|
||||
self.write(self.legacy / "rasci.json", "{}\n")
|
||||
with open(hold, encoding="utf-8") as held:
|
||||
fcntl.flock(held, fcntl.LOCK_EX)
|
||||
with self.assertRaises(ValueError) as raised:
|
||||
self.migrate()
|
||||
self.assertIn(f"{hold} is held", str(raised.exception))
|
||||
self.write(self.legacy / "queue.json", json.dumps({"seq": 3, "entries": [{"id": "test-3"}]}))
|
||||
with self.assertRaises(ValueError) as raised:
|
||||
self.migrate()
|
||||
self.assertIn(f"{self.legacy / 'queue.json'} holds 1 queue jobs", str(raised.exception))
|
||||
self.assertFalse(self.target.exists())
|
||||
self.assertEqual(sorted(path.name for path in self.legacy.iterdir()), ["holds", "queue.json", "rasci.json"])
|
||||
self.write(self.legacy / "queue.json", json.dumps({"seq": 3, "entries": []}))
|
||||
self.assertEqual(self.migrate(), [f"moved 3 files from {self.legacy} to {self.target}"])
|
||||
|
||||
def test_an_id_journal_gets_only_the_rows_it_lacks(self):
|
||||
kept = self.write(self.target / "queue-history.jsonl", '{"id": "a"}\n{"id": "b"}\n')
|
||||
self.write(self.legacy / "queue-history.jsonl", '{"id": "b"}\n{"id": "c"}\n{"id": "c"}\n')
|
||||
self.assertEqual(self.migrate(), [f"merged 1 rows of {self.legacy / 'queue-history.jsonl'} into {kept}"])
|
||||
self.assertEqual(rows(kept), ["a", "b", "c"])
|
||||
self.assertFalse(self.legacy.exists())
|
||||
self.assertEqual(self.migrate(), [])
|
||||
self.assertEqual(rows(kept), ["a", "b", "c"])
|
||||
|
||||
def test_a_merge_appends_after_a_row_another_writer_adds_meanwhile(self):
|
||||
self.write(self.legacy / "news.jsonl", '{"id": "L1"}\n')
|
||||
kept = self.write(self.target / "news.jsonl", '{"id": "T1"}\n')
|
||||
real, calls = self.councilroot.row_ids, []
|
||||
|
||||
def racing(text: str):
|
||||
calls.append(text)
|
||||
if len(calls) == 2:
|
||||
with open(kept, "a", encoding="utf-8") as other:
|
||||
other.write('{"id": "CONCURRENT"}\n')
|
||||
return real(text)
|
||||
|
||||
with mock.patch.object(self.councilroot, "row_ids", racing):
|
||||
self.assertEqual(self.migrate(), [f"merged 1 rows of {self.legacy / 'news.jsonl'} into {kept}"])
|
||||
self.assertEqual(rows(kept), ["T1", "CONCURRENT", "L1"])
|
||||
|
||||
def test_a_journal_without_ids_merges_each_line_as_often_as_the_legacy_side_has_it_more_in_ts_order(self):
|
||||
kept = self.write(self.target / "news.jsonl", '{"ts": 1.0, "text": "a"}\n{"ts": 3.0, "text": "c"}\n')
|
||||
self.write(self.legacy / "news.jsonl", '{"ts": 3.0, "text": "c"}\n{"ts": 2.0, "text": "b"}\n{"ts": 2.0, "text": "b"}\n')
|
||||
untimed = self.write(self.target / "scores.jsonl", '{"time": 1}\n')
|
||||
self.write(self.legacy / "scores.jsonl", '{"time": 2}\n{"time": 1}\n{"time": 1}\n{"time": 1}\n')
|
||||
self.assertEqual(self.migrate(), [
|
||||
f"merged 2 rows of {self.legacy / 'news.jsonl'} into {kept}",
|
||||
f"merged 3 rows of {self.legacy / 'scores.jsonl'} into {untimed}",
|
||||
])
|
||||
self.assertEqual([json.loads(line)["text"] for line in kept.read_text(encoding="utf-8").splitlines()], ["a", "b", "b", "c"])
|
||||
self.assertEqual(untimed.read_text(encoding="utf-8"), '{"time": 1}\n{"time": 2}\n{"time": 1}\n{"time": 1}\n')
|
||||
self.assertEqual(kept.stat().st_mode & 0o777, 0o600)
|
||||
self.assertFalse(self.legacy.exists())
|
||||
|
||||
def test_no_link_on_either_side_is_followed(self):
|
||||
secret = self.write(self.base / "secret.txt", "secret\n")
|
||||
outside = self.base / "outside"
|
||||
self.write(outside / "inner.txt", "inner\n")
|
||||
elsewhere = self.base / "elsewhere"
|
||||
elsewhere.mkdir()
|
||||
(self.legacy / "evil").symlink_to(secret)
|
||||
(self.legacy / "linked").symlink_to(outside)
|
||||
self.write(self.legacy / "work" / "a" / "claim.json", "{}\n")
|
||||
self.target.mkdir(parents=True, mode=0o700)
|
||||
(self.target / "work").symlink_to(elsewhere)
|
||||
with self.assertRaises(self.councilroot.Blocked) as blocked:
|
||||
self.migrate()
|
||||
self.assertTrue(all(line.startswith(f"unmoved {self.legacy / 'work' / 'a' / 'claim.json'}: ") for line in blocked.exception.lines), blocked.exception.lines)
|
||||
report = self.councilroot.migrate(self.legacy, self.target, True)
|
||||
self.assertIn(f"skipped {self.legacy / 'evil'}: not a regular file", report)
|
||||
self.assertIn(f"skipped {self.legacy / 'linked'}: a link", report)
|
||||
self.assertTrue(any(re.match(rf"unmoved {re.escape(str(self.legacy / 'work' / 'a' / 'claim.json'))}\.[0-9a-f]{{16}}\.migrating: ", line) for line in report), report)
|
||||
self.assertEqual(list(elsewhere.iterdir()), [])
|
||||
self.assertFalse((self.target / "evil").exists() or (self.target / "linked").exists())
|
||||
self.assertEqual((secret.read_text(encoding="utf-8"), (outside / "inner.txt").read_text(encoding="utf-8")), ("secret\n", "inner\n"))
|
||||
|
||||
def test_a_linked_or_shared_legacy_root_is_refused(self):
|
||||
linked = self.base / "linked-legacy"
|
||||
linked.symlink_to(self.legacy)
|
||||
with self.assertRaises(ValueError):
|
||||
self.councilroot.migrate(linked, self.target)
|
||||
self.legacy.chmod(0o777)
|
||||
self.addCleanup(self.legacy.chmod, 0o700)
|
||||
done = self.cli("migrate", "--legacy", str(self.legacy), AGENTS_COUNCIL_ROOT=str(self.target))
|
||||
self.assertEqual(done.returncode, 2)
|
||||
self.assertIn("group and others cannot write", done.stderr)
|
||||
|
||||
def test_a_missing_legacy_root_moves_nothing(self):
|
||||
done = self.cli("migrate", "--legacy", str(self.base / "gone"), AGENTS_COUNCIL_ROOT=str(self.target))
|
||||
self.assertEqual((done.returncode, done.stdout), (0, f"nothing to move from {self.base / 'gone'}\n"))
|
||||
|
||||
def test_orchestrator_stop_covers_every_unit_that_writes_a_council_root(self):
|
||||
units = (REPO_ROOT / "scripts" / "orchestrator.sh").read_text(encoding="utf-8")
|
||||
body = units[units.index("stop_all() {"):]
|
||||
body = body[:body.index("\n}\n")]
|
||||
for unit in ("${RUNNER}", "${OFFICES_UNIT}.path", "${RESOURCES_UNIT}.timer", "${RESOURCES_UNIT}.service", "compose"):
|
||||
with self.subTest(unit=unit):
|
||||
self.assertIn(unit, body)
|
||||
self.assertIn("stop) stop_all ;;", units)
|
||||
|
||||
|
||||
NPX_STUB = """#!/usr/bin/env python3
|
||||
import json, os
|
||||
from pathlib import Path
|
||||
with open(os.environ["STUB_RECORD"], "a") as record:
|
||||
record.write(f"npx {Path(os.environ['STUB_CHECK']).is_file()}\\n")
|
||||
if os.environ.get("STUB_LINK"):
|
||||
os.link(*json.loads(os.environ["STUB_LINK"]))
|
||||
skill = Path(".agents/skills/kvb-new/SKILL.md")
|
||||
skill.parent.mkdir(parents=True)
|
||||
skill.write_text("new\\n")
|
||||
"""
|
||||
CP_STUB = """#!/usr/bin/env python3
|
||||
import json, os, sys
|
||||
from pathlib import Path
|
||||
with open(os.environ["STUB_RECORD"], "a") as record:
|
||||
record.write(f"cp {Path(os.environ['STUB_CHECK']).is_file()} {sys.argv[-1]}\\n")
|
||||
if sys.argv[-1].startswith(os.environ["HOME"]):
|
||||
for late, text in json.loads(os.environ.get("STUB_LATE", "{}")).items():
|
||||
if not Path(late).exists():
|
||||
Path(late).parent.mkdir(parents=True, exist_ok=True)
|
||||
Path(late).write_text(text)
|
||||
os.execv(os.environ["REAL_CP"], ["cp", *sys.argv[1:]])
|
||||
"""
|
||||
TOOLS = ("bash", "python3", "dirname", "rm", "find", "mkdir", "install", "grep", "sed", "ln", "cat", "id")
|
||||
|
||||
|
||||
class Settings(Home):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.legacy = self.base / "legacy"
|
||||
self.legacy.mkdir(mode=0o700)
|
||||
self.settings = self.home / ".claude" / "settings.json"
|
||||
self.release = self.home / ".local" / "state" / "agents-release"
|
||||
self.allow(["~/.local/state/agents-shared", f"{self.release}/**", "/var/cache/unrelated", "."])
|
||||
|
||||
def allow(self, entries: list[str]) -> None:
|
||||
self.settings.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.settings.write_text(json.dumps({"sandbox": {"enabled": True, "filesystem": {"allowWrite": entries}}}), encoding="utf-8")
|
||||
|
||||
def preflight(self) -> subprocess.CompletedProcess:
|
||||
return self.cli("preflight", "--legacy", str(self.legacy), "--managed", str(self.base / "managed"))
|
||||
|
||||
def settings_file(self, path: Path, entries: list[str]) -> Path:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(json.dumps({"sandbox": {"filesystem": {"allowWrite": entries}}}), encoding="utf-8")
|
||||
return path
|
||||
|
||||
|
||||
class TestPreflight(Settings):
|
||||
def test_both_agent_paths_must_be_writable_for_the_sandbox_and_the_host_root_never(self):
|
||||
self.assertEqual(self.preflight().returncode, 0, self.preflight().stderr)
|
||||
for entries, wanted in (
|
||||
(["~/.local/state/agents-shared"], f"add {self.release} to sandbox.filesystem.allowWrite in {self.settings}"),
|
||||
([f"{self.release}"], f"add {self.shared} to sandbox.filesystem.allowWrite in {self.settings}"),
|
||||
(["~/.local/state/agents-shared", str(self.release), "~/.local/state/agents-council/**"], f"{self.settings}: drop allowWrite entry '~/.local/state/agents-council/**' ({self.durable})"),
|
||||
(["~/.local/state/agents-shared", str(self.release), "~/.local/state"], f"{self.settings}: drop allowWrite entry '~/.local/state' ({self.durable.parent})"),
|
||||
):
|
||||
with self.subTest(entries=entries):
|
||||
self.allow(entries)
|
||||
done = self.preflight()
|
||||
self.assertEqual(done.returncode, 2)
|
||||
self.assertIn(wanted, done.stderr)
|
||||
self.settings.unlink()
|
||||
self.assertIn(f"{self.settings} holds no sandbox.filesystem.allowWrite list", self.preflight().stderr)
|
||||
|
||||
def test_every_settings_file_that_can_apply_is_checked_and_named_with_its_entry(self):
|
||||
repo = self.home / "Repositories" / "github.com" / "o" / "r"
|
||||
worktree = self.home / ".local" / "share" / "worktrees" / "github.com" / "o" / "r" / "fix" / "x"
|
||||
widening = (
|
||||
(self.base / "managed" / "managed-settings.json", "~"),
|
||||
(self.base / "managed" / "managed-settings.d" / "50-widen.json", "~/.local"),
|
||||
(self.home / ".claude" / "settings.local.json", "~/.local/state/agents-council"),
|
||||
(repo / ".claude" / "settings.json", "~/.local/state"),
|
||||
(repo / ".claude" / "settings.local.json", "../../../../.local"),
|
||||
(worktree / ".claude" / "settings.json", "~/.local/state/agents-council/resources/**"),
|
||||
)
|
||||
self.settings_file(repo / "nested" / ".claude" / "settings.json", ["/var/cache/fine"])
|
||||
self.assertEqual(self.preflight().returncode, 0, self.preflight().stderr)
|
||||
for path, entry in widening:
|
||||
with self.subTest(path=path):
|
||||
self.settings_file(path, [entry, "/var/cache/fine"])
|
||||
done = self.preflight()
|
||||
self.assertEqual(done.returncode, 2)
|
||||
self.assertIn(f"{path}: drop allowWrite entry {entry!r}", done.stderr)
|
||||
self.assertNotIn("add ", done.stderr)
|
||||
path.unlink()
|
||||
moved = self.home / "Code" / "o" / "r" / ".claude" / "settings.json"
|
||||
self.settings_file(moved, ["~/.local/state"])
|
||||
self.assertEqual(self.preflight().returncode, 0)
|
||||
config = self.home / ".config" / "pkgmgr" / "config.yaml"
|
||||
config.parent.mkdir(parents=True)
|
||||
config.write_text("directories:\n repositories: ~/Code/\n binaries: ~/.local/bin/\n", encoding="utf-8")
|
||||
self.assertIn(f"{moved}: drop allowWrite entry '~/.local/state'", self.preflight().stderr)
|
||||
|
||||
def test_the_queue_and_the_preflight_share_one_list_of_settings_files(self):
|
||||
self.assertNotIn("managed-settings", QUEUE.read_text(encoding="utf-8"))
|
||||
managed = self.base / "managed"
|
||||
dropin = managed / "managed-settings.d" / "50-deny.json"
|
||||
dropin.parent.mkdir(parents=True)
|
||||
dropin.write_text(json.dumps({"permissions": {"deny": ["Bash(rm *)"]}}), encoding="utf-8")
|
||||
queue = load(QUEUE, f"test_council_root_queue_settings_{id(self)}")
|
||||
project = self.base / "project"
|
||||
with mock.patch.object(queue.sibling("councilroot"), "MANAGED", managed):
|
||||
self.assertIn(dropin, queue.settings_files(project))
|
||||
self.assertEqual(queue.permission(["rm -rf x"], project), "deny")
|
||||
|
||||
def test_linked_repositories_linked_files_and_every_session_start_directory_are_checked(self):
|
||||
repositories = self.home / "Repositories"
|
||||
data = self.base / "data" / "r"
|
||||
linked = repositories / "github.com" / "o" / "r"
|
||||
linked.parent.mkdir(parents=True)
|
||||
linked.symlink_to(data)
|
||||
(repositories / "loop").symlink_to(repositories)
|
||||
project = self.home / "work" / "proj"
|
||||
session = self.home / ".claude" / "projects" / re.sub(r"[^A-Za-z0-9]", "-", str(project))
|
||||
session.mkdir(parents=True)
|
||||
(self.home / ".claude" / "projects" / "-gone-project").mkdir()
|
||||
target = self.settings_file(self.base / "shared-settings.json", ["~/.local/state"])
|
||||
cases = (
|
||||
(linked / ".claude" / "settings.json", lambda path: self.settings_file(data / ".claude" / "settings.json", ["~/.local/state"])),
|
||||
(project / ".claude" / "settings.local.json", lambda path: self.settings_file(path, ["~/.local/state"])),
|
||||
(repositories / "github.com" / "o" / "s" / ".claude" / "settings.json", lambda path: (path.parent.mkdir(parents=True), path.symlink_to(target))),
|
||||
)
|
||||
self.settings_file(project / "deeper" / ".claude" / "settings.json", ["~/.local/state"])
|
||||
self.assertEqual(self.preflight().returncode, 0, self.preflight().stderr)
|
||||
for path, make in cases:
|
||||
with self.subTest(path=path):
|
||||
make(path)
|
||||
done = self.preflight()
|
||||
self.assertEqual(done.returncode, 2)
|
||||
self.assertEqual(done.stderr.count(f"{path}: drop allowWrite entry '~/.local/state'"), 1, done.stderr)
|
||||
path.unlink()
|
||||
|
||||
def test_a_council_that_is_not_suspended_is_only_warned_about(self):
|
||||
done = self.preflight()
|
||||
self.assertEqual(done.returncode, 0, done.stderr)
|
||||
self.assertIn("warning: the agents are not suspended", done.stderr)
|
||||
(self.legacy / "night.json").write_text(json.dumps({"mode": "suspend"}), encoding="utf-8")
|
||||
done = self.preflight()
|
||||
self.assertEqual((done.returncode, done.stderr), (0, ""))
|
||||
|
||||
def test_a_busy_or_conflicting_legacy_root_is_refused_before_anything_moves(self):
|
||||
hold = self.legacy / "holds" / "1-2.lock"
|
||||
hold.parent.mkdir()
|
||||
hold.write_text("", encoding="utf-8")
|
||||
with open(hold, encoding="utf-8") as held:
|
||||
fcntl.flock(held, fcntl.LOCK_EX)
|
||||
self.assertIn(f"{hold} is held", self.preflight().stderr)
|
||||
(self.legacy / "queue.json").write_text(json.dumps({"seq": 3, "entries": [{"id": "test-3"}]}), encoding="utf-8")
|
||||
self.assertIn("holds 1 queue jobs", self.preflight().stderr)
|
||||
(self.legacy / "queue.json").write_text(json.dumps({"seq": 3, "entries": []}), encoding="utf-8")
|
||||
for name, legacy, shared, ok in (("rasci.json", "a", "b", False), ("night.json", "same", "same", True), ("news.jsonl", '{"id": 1}\n', '{"id": 2}\n', True)):
|
||||
(self.legacy / name).write_text(legacy, encoding="utf-8")
|
||||
self.shared.mkdir(parents=True, mode=0o700, exist_ok=True)
|
||||
(self.shared / name).write_text(shared, encoding="utf-8")
|
||||
with self.subTest(name=name):
|
||||
self.assertEqual(f"conflict {self.shared / name} differs" in self.preflight().stderr, not ok)
|
||||
(self.legacy / "rasci.json").unlink()
|
||||
self.assertEqual(self.preflight().returncode, 0, self.preflight().stderr)
|
||||
self.assertEqual(sorted(path.name for path in self.legacy.iterdir()), ["holds", "news.jsonl", "night.json", "queue.json"])
|
||||
|
||||
|
||||
class TestInstall(Settings):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.repo = self.base / "repo"
|
||||
for part in ("scripts/install.sh", "scripts/orchestrator.sh", "skills/kvb-org-organize/scripts/councilroot.py", "skills/kvb-org-organize/scripts/nofollow.py"):
|
||||
(self.repo / part).parent.mkdir(parents=True, exist_ok=True)
|
||||
(self.repo / part).write_bytes((REPO_ROOT / part).read_bytes())
|
||||
stubs = self.base / "bin"
|
||||
stubs.mkdir()
|
||||
(stubs / "npx").write_text(NPX_STUB, encoding="utf-8")
|
||||
(stubs / "cp").write_text(CP_STUB, encoding="utf-8")
|
||||
(stubs / "systemctl").write_text("#!/bin/sh\nexit 1\n", encoding="utf-8")
|
||||
for stub in stubs.iterdir():
|
||||
stub.chmod(0o755)
|
||||
tools = self.base / "tools"
|
||||
tools.mkdir()
|
||||
for name in TOOLS:
|
||||
(tools / name).symlink_to(shutil.which(name))
|
||||
self.record = self.base / "stubs.log"
|
||||
self.installed = [self.home / root / "skills" / "kvb-old" / "SKILL.md" for root in (".agents", ".claude")]
|
||||
for marker in self.installed:
|
||||
marker.parent.mkdir(parents=True)
|
||||
marker.write_text("old\n", encoding="utf-8")
|
||||
self.env = {
|
||||
"PATH": f"{stubs}:{tools}", "HOME": str(self.home), "AGENTS_COUNCIL_LEGACY": str(self.legacy),
|
||||
"STUB_RECORD": str(self.record), "STUB_CHECK": str(self.shared / "rasci.json"), "REAL_CP": shutil.which("cp"),
|
||||
}
|
||||
|
||||
def install(self) -> subprocess.CompletedProcess:
|
||||
return subprocess.run(["bash", str(self.repo / "scripts" / "install.sh")], env=self.env, capture_output=True, text=True, timeout=120, check=False)
|
||||
|
||||
def test_a_refused_preflight_aborts_before_any_copy_and_the_old_skills_keep_the_legacy_state(self):
|
||||
(self.legacy / "queue.json").write_text(json.dumps({"seq": 3, "entries": [{"id": "test-3"}]}), encoding="utf-8")
|
||||
busy = self.install()
|
||||
self.allow(["~/.local/state/agents-shared"])
|
||||
(self.legacy / "queue.json").write_text(json.dumps({"seq": 3, "entries": []}), encoding="utf-8")
|
||||
unset = self.install()
|
||||
for done, reason in ((busy, "holds 1 queue jobs"), (unset, f"add {self.release} to sandbox.filesystem.allowWrite")):
|
||||
with self.subTest(reason=reason):
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertIn(reason, done.stderr)
|
||||
self.assertIn("skills: install refused before copying anything", done.stderr)
|
||||
self.assertFalse(self.record.exists() or self.shared.exists() or (self.repo / ".agents").exists())
|
||||
self.assertEqual([marker.read_text(encoding="utf-8") for marker in self.installed], ["old\n", "old\n"])
|
||||
self.assertTrue((self.legacy / "queue.json").is_file())
|
||||
|
||||
def test_a_migrate_that_fails_in_any_other_way_aborts_before_the_copy(self):
|
||||
script = self.repo / "skills" / "kvb-org-organize" / "scripts" / "councilroot.py"
|
||||
script.write_text(script.read_text(encoding="utf-8").replace("report = migrate(args.legacy, root(), args.catch_up)", 'raise RuntimeError("boom")'), encoding="utf-8")
|
||||
(self.legacy / "rasci.json").write_text("{}\n", encoding="utf-8")
|
||||
done = self.install()
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertIn("RuntimeError: boom", done.stderr)
|
||||
self.assertIn("skills: install refused before copying anything: the council root migration failed", done.stderr)
|
||||
self.assertEqual([marker.read_text(encoding="utf-8") for marker in self.installed], ["old\n", "old\n"])
|
||||
self.assertTrue((self.legacy / "rasci.json").is_file())
|
||||
|
||||
def test_a_file_that_turns_unmovable_after_the_preflight_aborts_with_the_old_root_intact(self):
|
||||
(self.legacy / "rasci.json").write_text('{"work/x": {}}\n', encoding="utf-8")
|
||||
(self.legacy / "queue.json").write_text('{"seq": 9, "entries": []}\n', encoding="utf-8")
|
||||
self.env["STUB_LINK"] = json.dumps([str(self.legacy / "rasci.json"), str(self.base / "alias")])
|
||||
done = self.install()
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertIn(f"unmoved {self.legacy / 'rasci.json'}: not a regular file with a single link", done.stdout)
|
||||
self.assertIn("skills: install refused before copying anything: the council root migration failed (exit 4)", done.stderr)
|
||||
self.assertEqual(sorted(path.name for path in self.legacy.iterdir()), ["queue.json", "rasci.json"])
|
||||
self.assertFalse((self.shared / "rasci.json").exists() or (self.shared / "queue.json").exists())
|
||||
self.assertEqual([marker.read_text(encoding="utf-8") for marker in self.installed], ["old\n", "old\n"])
|
||||
|
||||
def test_a_partial_move_still_installs_the_new_skills_names_every_file_left_and_fails_at_the_end(self):
|
||||
script = self.repo / "skills" / "kvb-org-organize" / "scripts" / "councilroot.py"
|
||||
script.write_text(script.read_text(encoding="utf-8").replace(
|
||||
"outcome, line = settle(helper, legacy, source, target, catch_up)",
|
||||
'outcome, line = ("unmoved", f"unmoved {source}: raced") if source.name == "late.json" else settle(helper, legacy, source, target, catch_up)',
|
||||
), encoding="utf-8")
|
||||
(self.legacy / "rasci.json").write_text("{}\n", encoding="utf-8")
|
||||
(self.legacy / "late.json").write_text("{}\n", encoding="utf-8")
|
||||
done = self.install()
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertGreaterEqual(done.stderr.count(f"unmoved {self.legacy / 'late.json'}: raced"), 2, done.stderr)
|
||||
self.assertTrue((self.shared / "rasci.json").is_file() and (self.legacy / "late.json").is_file())
|
||||
self.assertEqual([(marker.parent.parent / "kvb-new" / "SKILL.md").read_text(encoding="utf-8") for marker in self.installed], ["new\n"] * 2)
|
||||
|
||||
def test_a_crash_after_a_partial_move_still_installs_the_new_skills_and_names_the_marker(self):
|
||||
script = self.repo / "skills" / "kvb-org-organize" / "scripts" / "councilroot.py"
|
||||
settle = "outcome, line = settle(helper, legacy, source, target, catch_up)"
|
||||
script.write_text(script.read_text(encoding="utf-8").replace(settle, f'if source.name == "zz.json":\n raise RuntimeError("boom")\n {settle}'), encoding="utf-8")
|
||||
(self.legacy / "rasci.json").write_text("{}\n", encoding="utf-8")
|
||||
(self.legacy / "zz.json").write_text("{}\n", encoding="utf-8")
|
||||
done = self.install()
|
||||
marker = self.durable / "migrate.started"
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertIn("RuntimeError: boom", done.stderr)
|
||||
self.assertIn(f"skills: the council root migration stopped halfway (exit 1): {marker} exists", done.stderr)
|
||||
self.assertTrue((self.shared / "rasci.json").is_file() and marker.is_file() and (self.legacy / "zz.json").is_file())
|
||||
self.assertEqual([(old.parent.parent / "kvb-new" / "SKILL.md").read_text(encoding="utf-8") for old in self.installed], ["new\n"] * 2)
|
||||
|
||||
def test_rows_and_register_changes_written_meanwhile_arrive_or_are_reported_never_lost(self):
|
||||
(self.legacy / "queue-history.jsonl").write_text('{"id": "early"}\n', encoding="utf-8")
|
||||
(self.legacy / "news.jsonl").write_text(json.dumps({"from": "A", "text": "before", "ts": 1.0}) + "\n", encoding="utf-8")
|
||||
(self.legacy / "rasci.json").write_text("{}\n", encoding="utf-8")
|
||||
window = '{"work/x": {"status": "window"}}\n'
|
||||
self.env["STUB_LATE"] = json.dumps({
|
||||
str(self.legacy / "queue-history.jsonl"): '{"id": "late"}\n',
|
||||
str(self.legacy / "news.jsonl"): json.dumps({"from": "B", "text": "posted in the window", "ts": 2.0}) + "\n",
|
||||
str(self.legacy / "rasci.json"): window,
|
||||
})
|
||||
done = self.install()
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertEqual(rows(self.shared / "queue-history.jsonl"), ["early", "late"])
|
||||
self.assertEqual([json.loads(line)["text"] for line in (self.shared / "news.jsonl").read_text(encoding="utf-8").splitlines()], ["before", "posted in the window"])
|
||||
kept = [path for path in self.shared.iterdir() if path.name.startswith("rasci.json.legacy-")]
|
||||
self.assertEqual([path.read_text(encoding="utf-8") for path in kept], [window])
|
||||
self.assertEqual((self.shared / "rasci.json").read_text(encoding="utf-8"), "{}\n")
|
||||
self.assertIn(f"kept {self.legacy / 'rasci.json'} beside {self.shared / 'rasci.json'} as {kept[0]}", done.stderr)
|
||||
self.assertFalse(self.legacy.exists())
|
||||
|
||||
def test_the_skills_are_built_first_and_reach_the_target_only_after_the_legacy_state_moved(self):
|
||||
(self.legacy / "rasci.json").write_text("{}\n", encoding="utf-8")
|
||||
done = self.install()
|
||||
self.assertEqual(done.returncode, 0, done.stderr)
|
||||
calls = self.record.read_text(encoding="utf-8").splitlines()
|
||||
self.assertEqual(calls[0], "npx False", done.stderr)
|
||||
into_target = [call for call in calls if call.startswith("cp ") and call.split(" ", 2)[2].startswith(str(self.home))]
|
||||
self.assertEqual(into_target, [f"cp True {self.home / root / 'skills'}/" for root in (".agents", ".claude")], done.stderr)
|
||||
self.assertFalse(self.legacy.exists())
|
||||
self.assertEqual([(marker.exists(), (marker.parent.parent / "kvb-new" / "SKILL.md").read_text(encoding="utf-8")) for marker in self.installed], [(False, "new\n")] * 2)
|
||||
|
||||
|
||||
class TestKeptCopy(Home):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.watch = load(WATCH, f"test_council_root_watch_{id(self)}")
|
||||
|
||||
def write_rows(self, path: Path) -> None:
|
||||
path.write_text('{"id": "r1", "rule": "R", "path": "p", "sha1": "s"}\n{"id": "r2", "rule": "R", "path": "q", "sha1": "s"}\n', encoding="utf-8")
|
||||
|
||||
def test_agents_write_their_root_and_the_host_keeps_the_copies_apart(self):
|
||||
watch = self.watch
|
||||
self.assertEqual((watch.ROOT, watch.KEPT), (self.shared, self.durable))
|
||||
for origin, kept in watch.MIRRORED:
|
||||
with self.subTest(name=origin.name):
|
||||
self.assertEqual((origin.parent, kept.parent, origin.name), (self.shared, self.durable, kept.name))
|
||||
queue = load(QUEUE, f"test_council_root_queue_{id(self)}")
|
||||
self.assertEqual(queue.HISTORIES, (self.shared / "queue-history.jsonl", self.durable / "queue-history.jsonl"))
|
||||
|
||||
def test_the_hook_mirrors_acceptances_and_receipts_into_the_host_root_and_readers_merge_both(self):
|
||||
watch = self.watch
|
||||
self.shared.mkdir(parents=True, mode=0o700)
|
||||
for origin, _ in watch.MIRRORED:
|
||||
self.write_rows(origin)
|
||||
watch.keep_history()
|
||||
for _, kept in watch.MIRRORED:
|
||||
with self.subTest(name=kept.name):
|
||||
self.assertEqual((rows(kept), kept.stat().st_mode & 0o777), (["r1", "r2"], 0o600))
|
||||
self.assertEqual(self.durable.stat().st_mode & 0o777, 0o700)
|
||||
with watch.KEPT_ACCEPTED.open("a", encoding="utf-8") as kept:
|
||||
kept.write('{"id": "r0", "rule": "R", "path": "o", "sha1": "s"}\n')
|
||||
security = load(SECURITY, f"test_council_root_security_{id(self)}")
|
||||
self.assertEqual(security.accepted((watch.ACCEPTED, watch.KEPT_ACCEPTED)), {("R", name, "s", None) for name in "opq"})
|
||||
|
||||
def test_the_mirror_never_follows_a_link_in_the_host_root(self):
|
||||
watch = self.watch
|
||||
self.shared.mkdir(parents=True, mode=0o700)
|
||||
self.durable.mkdir(parents=True, mode=0o700)
|
||||
self.write_rows(watch.ACCEPTED)
|
||||
outside = self.base / "outside.jsonl"
|
||||
outside.write_text("", encoding="utf-8")
|
||||
watch.KEPT_ACCEPTED.symlink_to(outside)
|
||||
watch.keep_rows(watch.ACCEPTED, watch.KEPT_ACCEPTED)
|
||||
self.assertEqual(outside.read_text(encoding="utf-8"), "")
|
||||
watch.KEPT_ACCEPTED.unlink()
|
||||
os.link(outside, watch.KEPT_ACCEPTED)
|
||||
watch.keep_rows(watch.ACCEPTED, watch.KEPT_ACCEPTED)
|
||||
self.assertEqual(outside.read_text(encoding="utf-8"), "")
|
||||
watch.KEPT_ACCEPTED.unlink()
|
||||
elsewhere = self.base / "elsewhere"
|
||||
elsewhere.mkdir()
|
||||
self.durable.rmdir()
|
||||
self.durable.symlink_to(elsewhere)
|
||||
watch.keep_rows(watch.ACCEPTED, watch.KEPT_ACCEPTED)
|
||||
self.assertEqual(list(elsewhere.iterdir()), [])
|
||||
|
||||
def test_the_watch_hook_never_copies_a_journal_onto_itself(self):
|
||||
with mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": str(self.durable)}):
|
||||
watch = load(WATCH, f"test_council_root_same_{id(self)}")
|
||||
self.durable.mkdir(parents=True, mode=0o700)
|
||||
for origin, _ in watch.MIRRORED:
|
||||
self.write_rows(origin)
|
||||
before = {origin: origin.read_bytes() for origin, _ in watch.MIRRORED}
|
||||
watch.keep_history()
|
||||
self.assertEqual({origin: origin.read_bytes() for origin, _ in watch.MIRRORED}, before)
|
||||
|
||||
def test_an_explicit_root_still_keeps_its_rows_in_the_durable_one(self):
|
||||
with mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": str(self.base / "council")}):
|
||||
watch = load(WATCH, f"test_council_root_explicit_{id(self)}")
|
||||
self.assertEqual((watch.ROOT, watch.KEPT), (self.base / "council", self.durable))
|
||||
watch.ROOT.mkdir(mode=0o700)
|
||||
self.write_rows(watch.HISTORY)
|
||||
watch.keep_history()
|
||||
self.assertEqual(rows(watch.KEPT_HISTORY), ["r1", "r2"])
|
||||
|
||||
|
||||
class TestHostWriters(Home):
|
||||
def outside(self) -> Path:
|
||||
path = self.base / "outside"
|
||||
path.write_text("", encoding="utf-8")
|
||||
return path
|
||||
|
||||
def test_the_subagent_log_lies_in_the_host_root_and_never_follows_a_link(self):
|
||||
payload = json.dumps({"session_id": "s1", "tool_input": {"description": "d", "prompt": "task-class: judgement"}})
|
||||
state = self.base / "xdg"
|
||||
env = {"PATH": os.environ["PATH"], "HOME": str(self.home), "XDG_STATE_HOME": str(state)}
|
||||
spawn = subprocess.run([sys.executable, str(LOG), "spawn"], input=payload, env=env, capture_output=True, text=True, check=False)
|
||||
self.assertEqual(spawn.returncode, 0, spawn.stderr)
|
||||
log = state / "agents-council" / "subagent-model.jsonl"
|
||||
self.assertEqual(json.loads(log.read_text(encoding="utf-8"))["task_class"], "judgement")
|
||||
outside = self.outside()
|
||||
log.unlink()
|
||||
log.symlink_to(outside)
|
||||
subprocess.run([sys.executable, str(LOG), "spawn"], input=payload, env=env, capture_output=True, text=True, check=False)
|
||||
self.assertEqual(outside.read_text(encoding="utf-8"), "")
|
||||
|
||||
def resources(self) -> ModuleType:
|
||||
with mock.patch.object(sys, "path", [str(CLIENT), *sys.path]):
|
||||
return load(CLIENT / "resources.py", f"test_council_root_resources_{id(self)}")
|
||||
|
||||
def test_the_resources_sampler_never_follows_a_link(self):
|
||||
resources = self.resources()
|
||||
state = self.durable / "resources"
|
||||
state.mkdir(parents=True, mode=0o700)
|
||||
outside = self.outside()
|
||||
(state / "samples.jsonl").symlink_to(outside)
|
||||
with self.assertRaises(OSError):
|
||||
resources.append_rows(state / "samples.jsonl", [{"t": 1}])
|
||||
self.assertEqual(outside.read_text(encoding="utf-8"), "")
|
||||
elsewhere = self.base / "elsewhere"
|
||||
elsewhere.mkdir()
|
||||
(state / "samples.jsonl").unlink()
|
||||
state.rmdir()
|
||||
state.symlink_to(elsewhere)
|
||||
for write in (lambda: resources.append_rows(state / "tokens.jsonl", [{"t": 1}]), lambda: resources.replace(state / "offsets.json", "{}")):
|
||||
with self.assertRaises(OSError):
|
||||
write()
|
||||
self.assertEqual(list(elsewhere.iterdir()), [])
|
||||
|
||||
def gates(self) -> ModuleType:
|
||||
return load(GATES, f"test_council_root_gates_{id(self)}")
|
||||
|
||||
def test_gates_db_is_never_written_through_a_link(self):
|
||||
gates = self.gates()
|
||||
self.durable.mkdir(parents=True, mode=0o700)
|
||||
outside = self.outside()
|
||||
(self.durable / "gates.db").symlink_to(outside)
|
||||
with self.assertRaises(OSError):
|
||||
gates.opened(self.durable / "gates.db", True, self.durable)
|
||||
self.assertEqual(outside.read_bytes(), b"")
|
||||
|
||||
def test_an_unusable_council_root_is_named_in_the_gate_hint_instead_of_a_traceback(self):
|
||||
target = self.base / "target"
|
||||
target.mkdir()
|
||||
linked = self.base / "linked"
|
||||
linked.symlink_to(target)
|
||||
with mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": str(linked)}):
|
||||
gates = self.gates()
|
||||
hint = gates.producer(str(self.base), "main", "test", "0" * 40)
|
||||
self.assertIn(f"{linked} must be a directory of uid {os.getuid()}", hint)
|
||||
self.assertEqual(list(target.iterdir()), [])
|
||||
|
||||
|
||||
class TestRetention(Home):
|
||||
def setUp(self):
|
||||
super().setUp()
|
||||
self.shared.mkdir(parents=True, mode=0o700)
|
||||
self.radio = load(RADIO, f"test_council_root_radio_{id(self)}")
|
||||
|
||||
def test_an_oversized_radio_log_still_yields_its_newest_rows(self):
|
||||
row = json.dumps({"from": "A", "to": ["B"], "class": "mayday", "text": "mayday", "ts": 2.0}) + "\n"
|
||||
filler = json.dumps({"from": "A", "text": "x" * 200, "ts": 1.0}) + "\n"
|
||||
self.radio.NEWS.write_text(filler * 20 + row, encoding="utf-8")
|
||||
with mock.patch.object(self.radio.organize("nofollow"), "READ_LIMIT", 1024):
|
||||
found = self.radio.items()
|
||||
self.assertEqual(found[-1]["text"], "mayday")
|
||||
self.assertLess(len(found), 6)
|
||||
|
||||
def test_rows_the_radio_drops_go_to_a_dated_archive_the_readers_skip(self):
|
||||
with mock.patch.object(self.radio, "KEPT", 3):
|
||||
for number in range(5):
|
||||
self.radio.store([{"from": "A", "text": f"m{number}"}])
|
||||
self.assertEqual([row["text"] for row in self.radio.items()], ["m2", "m3", "m4"])
|
||||
archive = self.shared / "archive" / f"news-{time.strftime('%Y-%m-%d')}.jsonl"
|
||||
self.assertEqual([json.loads(line)["text"] for line in archive.read_text(encoding="utf-8").splitlines()], ["m0", "m1"])
|
||||
self.assertEqual(archive.stat().st_mode & 0o777, 0o600)
|
||||
|
||||
def test_old_gate_logs_and_pages_move_to_a_dated_archive_and_links_stay(self):
|
||||
old = time.time() - 31 * 86400
|
||||
stale = {self.shared / "gates" / "slug" / "gate-a.log", self.shared / "pages" / "branch" / "index.html"}
|
||||
fresh = self.shared / "gates" / "slug" / "gate-b.log"
|
||||
for path in (*stale, fresh):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text("x\n", encoding="utf-8")
|
||||
for path in stale:
|
||||
os.utime(path, (old, old))
|
||||
outside = self.base / "outside.log"
|
||||
outside.write_text("keep\n", encoding="utf-8")
|
||||
os.utime(outside, (old, old))
|
||||
(self.shared / "gates" / "linked.log").symlink_to(outside)
|
||||
done = self.cli("retire")
|
||||
archive = self.shared / "archive" / time.strftime("%Y-%m-%d")
|
||||
self.assertEqual((done.returncode, done.stdout), (0, f"archived 2 files into {archive}\n"), done.stderr)
|
||||
self.assertEqual(sorted(str(path.relative_to(archive)) for path in archive.rglob("*") if path.is_file()), ["gates/slug/gate-a.log", "pages/branch/index.html"])
|
||||
self.assertTrue(fresh.is_file() and (self.shared / "gates" / "linked.log").is_symlink())
|
||||
self.assertEqual(outside.read_text(encoding="utf-8"), "keep\n")
|
||||
self.assertIn("ExecStartPre=-/usr/bin/python3 -I %h/.claude/skills/kvb-org-organize/scripts/councilroot.py retire\n", CLEANUP_SERVICE.read_text(encoding="utf-8"))
|
||||
|
||||
|
||||
class TestGuard(unittest.TestCase):
|
||||
def test_no_script_or_skill_text_keeps_persistent_data_in_tmp(self):
|
||||
hits = []
|
||||
for top in SCANNED:
|
||||
for path in sorted((REPO_ROOT / top).rglob("*")):
|
||||
if not path.is_file() or "__pycache__" in path.parts:
|
||||
continue
|
||||
for number, line in enumerate(path.read_text(encoding="utf-8", errors="replace").splitlines(), 1):
|
||||
if FORBIDDEN.search(line) and not (path == COUNCIL_ROOT and line == LEGACY_LINE):
|
||||
hits.append(f"{path.relative_to(REPO_ROOT)}:{number}")
|
||||
self.assertEqual(hits, [])
|
||||
|
||||
def test_the_legacy_root_is_named_once_as_the_migration_source(self):
|
||||
found = [line for line in COUNCIL_ROOT.read_text(encoding="utf-8").splitlines() if "/tmp/agents-council" in line]
|
||||
self.assertEqual(found, [LEGACY_LINE])
|
||||
|
||||
def test_no_skill_text_turns_a_failed_dir_call_into_a_root_path(self):
|
||||
hits = [str(path.relative_to(REPO_ROOT)) for path in sorted((REPO_ROOT / "skills").rglob("*.md")) if DIR_SLASH.search(path.read_text(encoding="utf-8"))]
|
||||
self.assertEqual(hits, [])
|
||||
|
||||
def test_the_agent_root_is_named_where_it_is_inventoried_or_mounted(self):
|
||||
self.assertIn("~/.local/state/agents-shared", (REPO_ROOT / "skills" / "kvb-cleanup" / "SKILL.md").read_text(encoding="utf-8"))
|
||||
self.assertIn("~/.local/state/agents-shared.", (CLIENT / "offices.py").read_text(encoding="utf-8"))
|
||||
mounts = (REPO_ROOT / "docs" / "requirements" / "003-operator-workbench.md").read_text(encoding="utf-8").split("- **Mounts**:", 1)[1].split("\n\n", 1)[0]
|
||||
self.assertIn("`~/.local/state/agents-shared`", mounts)
|
||||
self.assertNotIn("the same directory is also", mounts)
|
||||
|
||||
def test_gate_logs_never_go_to_the_temp_directory(self):
|
||||
found = [str(path.relative_to(REPO_ROOT)) for path in sorted(GATE_SKILL.rglob("*.py")) if "gettempdir" in path.read_text(encoding="utf-8")]
|
||||
self.assertEqual(found, [])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
+1
-1
@@ -276,7 +276,7 @@ class TestInstalledHooks(Scratch):
|
||||
tree = self.out("write-tree")
|
||||
self.assertIn(f"gates: commit on main needs test (rule of main); no receipt for tree {tree} meets it.", refused.stderr)
|
||||
command = self.produce_command(refused.stderr)
|
||||
log = self.base / f"gate-{tree[:12]}-test.log"
|
||||
log = self.council / "gates" / f"gate-{tree[:12]}-test.log"
|
||||
self.assertEqual(command[:6], ["env", "-C", str(self.repo), "INFINITO_TEST_GPU=false", "python3", str(QUEUE)])
|
||||
self.assertEqual(
|
||||
command[6:], ["hold", "--kind", "test", "--task", "work/gate", "--receipt", "test", "--log", str(log), "--", "make", "test"]
|
||||
|
||||
@@ -14,8 +14,8 @@ from pathlib import Path
|
||||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
SCRIPT = REPO_ROOT / "scripts" / "orchestrator.sh"
|
||||
HOST_SCRIPTS = (
|
||||
"kvb-org-organize/scripts/council.py", "kvb-org-organize/scripts/nofollow.py", "kvb-org-rasci/scripts/rasci.py",
|
||||
"kvb-org-operator/scripts/operator.py", "kvb-org-radio/scripts/radio.py",
|
||||
"kvb-org-organize/scripts/council.py", "kvb-org-organize/scripts/nofollow.py", "kvb-org-organize/scripts/councilroot.py",
|
||||
"kvb-org-rasci/scripts/rasci.py", "kvb-org-operator/scripts/operator.py", "kvb-org-radio/scripts/radio.py",
|
||||
)
|
||||
OLD = "kvb-hub"
|
||||
NEW = "kvb-orchestrator"
|
||||
@@ -33,6 +33,8 @@ if tool == "docker" and args[:2] == ["image", "inspect"]:
|
||||
elif tool == "docker" and args[:2] == ["image", "rm"]:
|
||||
code = 0 if args[2] in state["images"] else 1
|
||||
state["images"] = [image for image in state["images"] if image != args[2]]
|
||||
elif tool == "docker" and args[0] == "compose" and "build" in args:
|
||||
code = 1 if state.get("fail_build") else 0
|
||||
elif tool == "docker" and args[0] == "compose" and "up" in args:
|
||||
state["images"] = sorted({*state["images"], "kvb-orchestrator:local"})
|
||||
elif tool == "claude" and args[:2] == ["mcp", "get"]:
|
||||
@@ -88,6 +90,7 @@ class TestOrchestratorMigration(unittest.TestCase):
|
||||
self.state = self.root / "stub.json"
|
||||
self.state.write_text(json.dumps({"calls": [], "images": [f"{OLD}:local"], "mcp": {OLD: "http://127.0.0.1:8737/mcp"}, "enabled": [f"{OLD}-runner.service"]}), encoding="utf-8")
|
||||
self.env = {**os.environ, "HOME": str(self.home), "PATH": f"{stubs}:{os.environ['PATH']}", "STUB_STATE": str(self.state), "AGENTS_COUNCIL_ROOT": str(self.root / "council"), "PKGMGR_REPO": str(self.root / "no-pkgmgr")}
|
||||
self.env.pop("XDG_STATE_HOME", None)
|
||||
share, local, config = self.home / ".local" / "share", self.home / ".local" / "state", self.home / ".config"
|
||||
self.write(share / OLD / "compose.yml", f"name: {OLD}\n")
|
||||
self.write(share / OLD / ".env", "KVB_HUB_PORT=8737\n")
|
||||
@@ -146,6 +149,29 @@ class TestOrchestratorMigration(unittest.TestCase):
|
||||
legacy_calls = [call for call in second["calls"][len(first["calls"]) :] if any(OLD in arg for arg in call)]
|
||||
self.assertEqual(legacy_calls, [["docker", "image", "inspect", f"{OLD}:local"], ["claude", "mcp", "get", OLD]])
|
||||
|
||||
def test_install_hands_the_hub_the_agents_root_and_the_host_only_root_apart(self):
|
||||
del self.env["AGENTS_COUNCIL_ROOT"]
|
||||
self.install()
|
||||
state = self.home / ".local" / "state"
|
||||
env = (self.home / ".local" / "share" / NEW / ".env").read_text(encoding="utf-8").splitlines()
|
||||
self.assertLessEqual({f"KVB_ORCHESTRATOR_COUNCIL={state / 'agents-shared'}", f"KVB_ORCHESTRATOR_KEPT={state / 'agents-council'}"}, set(env))
|
||||
self.assertTrue((state / "agents-council" / "resources").is_dir())
|
||||
|
||||
def test_the_hub_is_built_before_it_is_replaced_and_a_failed_build_leaves_it_down_and_fails(self):
|
||||
self.install()
|
||||
hub = str(self.home / ".local" / "share" / NEW / "compose.yml")
|
||||
first = json.loads(self.state.read_text(encoding="utf-8"))
|
||||
self.assertEqual([call[4:] for call in first["calls"] if call[:4] == ["docker", "compose", "--file", hub]], [["build"], ["up", "-d"]])
|
||||
self.state.write_text(json.dumps({**first, "calls": [], "fail_build": True}), encoding="utf-8")
|
||||
done = subprocess.run(["bash", str(SCRIPT), "install"], env=self.env, capture_output=True, text=True, timeout=120, check=False)
|
||||
self.assertEqual(done.returncode, 1, done.stderr)
|
||||
self.assertIn("building the Agent Orchestrator failed; it stays down until 'bash scripts/orchestrator.sh install' succeeds", done.stderr)
|
||||
after = json.loads(self.state.read_text(encoding="utf-8"))
|
||||
self.assertEqual([call[4:] for call in after["calls"] if call[:4] == ["docker", "compose", "--file", hub]], [["build"], ["stop"]])
|
||||
self.assertIn(f"{NEW}-resources.timer", after["enabled"])
|
||||
installer = (REPO_ROOT / "scripts" / "install.sh").read_text(encoding="utf-8")
|
||||
self.assertIn('if ! bash "${REPO_ROOT}/scripts/orchestrator.sh" install; then', installer)
|
||||
|
||||
def test_check_reports_the_sessions_timer_the_install_enabled_as_active(self):
|
||||
for tool in ("curl", "journalctl"):
|
||||
(self.root / "bin" / tool).symlink_to("stub")
|
||||
|
||||
@@ -693,7 +693,13 @@ class TestQueueCleanup(unittest.TestCase):
|
||||
inode = request.stat().st_ino
|
||||
self.cli("request")
|
||||
self.assertEqual((request.stat().st_ino, len(request.read_text(encoding="utf-8").splitlines())), (inode, 2))
|
||||
self.assertIn("PathModified=/tmp/agents-council/queue-cleanup.request\n", unit.read_text(encoding="utf-8"))
|
||||
self.assertIn("PathModified=%S/agents-shared/queue-cleanup.request\n", unit.read_text(encoding="utf-8"))
|
||||
|
||||
def test_agents_request_in_their_root_and_the_round_state_stays_host_only(self):
|
||||
with mock.patch.dict(os.environ, {"AGENTS_COUNCIL_ROOT": ""}):
|
||||
cleanup = _load(CLEANUP)
|
||||
state = self.home / ".local" / "state"
|
||||
self.assertEqual((cleanup.REQUEST, cleanup.STATE), (state / "agents-shared" / "queue-cleanup.request", self.kept / "queue-cleanup.json"))
|
||||
|
||||
def test_request_refuses_during_a_round_and_for_30_minutes_after_one(self):
|
||||
self.install_unit()
|
||||
|
||||
@@ -139,6 +139,8 @@ class TestBackfill(unittest.TestCase):
|
||||
shutil.copy(BACKFILL.parent / name, scripts / name)
|
||||
shutil.copy(LABELS, scripts.parent / "labels.json")
|
||||
helper = scripts.parents[1] / "kvb-org-organize" / "scripts" / "nofollow.py"
|
||||
helper.parent.mkdir(parents=True)
|
||||
shutil.copy(REPO_ROOT / "skills" / "kvb-org-organize" / "scripts" / "councilroot.py", helper.parent / "councilroot.py")
|
||||
council = self.council("missing")
|
||||
env = {"PATH": os.environ["PATH"], "AGENTS_COUNCIL_ROOT": str(council)}
|
||||
done = subprocess.run([sys.executable, "-B", str(scripts / "backfill.py"), "--repo", str(self.fixture.a)], env=env, capture_output=True, text=True, check=False, timeout=HANG)
|
||||
|
||||
@@ -26,6 +26,7 @@ REQUIREMENTS = REPO_ROOT / "docs" / "requirements"
|
||||
SCORE = SKILL / "scripts" / "score.py"
|
||||
EFFICIENCY = REPO_ROOT / "skills" / "kvb-check-efficiency" / "scripts"
|
||||
NOFOLLOW = REPO_ROOT / "skills" / "kvb-org-organize" / "scripts" / "nofollow.py"
|
||||
COUNCIL_ROOT = NOFOLLOW.with_name("councilroot.py")
|
||||
HANG = 20
|
||||
FORMER = re.compile(r"💸 Cost|⏱️ Time|(?i:💸 cost|⏱️ time|\bcost (?:and|or) time\b|\bcost, time\b|\b(?:cost|time) from the `kvb-check-(?:efficiency|speed)`)")
|
||||
REMOTES = (
|
||||
@@ -97,6 +98,7 @@ class ScoreCase(unittest.TestCase):
|
||||
organize = self.tmp / "skills" / "kvb-org-organize" / "scripts"
|
||||
organize.mkdir(parents=True)
|
||||
shutil.copy(NOFOLLOW, organize / "nofollow.py")
|
||||
shutil.copy(COUNCIL_ROOT, organize / "councilroot.py")
|
||||
(skill / "labels.json").write_text(labels, encoding="utf-8")
|
||||
return skill / "scripts" / "score.py"
|
||||
|
||||
@@ -171,12 +173,14 @@ class TestJournalPlace(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.journal = module(SKILL / "scripts" / "journal.py")
|
||||
|
||||
def test_an_empty_council_root_means_the_default(self):
|
||||
for value in ("", None):
|
||||
with self.subTest(value=value), mock.patch.dict(os.environ, {} if value is None else {"AGENTS_COUNCIL_ROOT": value}):
|
||||
if value is None:
|
||||
os.environ.pop("AGENTS_COUNCIL_ROOT", None)
|
||||
self.assertEqual(self.journal.journal_path(), Path("/tmp/agents-council/scores.jsonl"))
|
||||
def test_an_empty_council_root_means_the_durable_agents_default(self):
|
||||
with tempfile.TemporaryDirectory() as home:
|
||||
for value in ("", None):
|
||||
with self.subTest(value=value), mock.patch.dict(os.environ, {"HOME": home} if value is None else {"HOME": home, "AGENTS_COUNCIL_ROOT": value}):
|
||||
os.environ.pop("XDG_STATE_HOME", None)
|
||||
if value is None:
|
||||
os.environ.pop("AGENTS_COUNCIL_ROOT", None)
|
||||
self.assertEqual(self.journal.journal_path(), Path(home) / ".local" / "state" / "agents-shared" / "scores.jsonl")
|
||||
|
||||
def test_ssh_scp_and_https_remotes_share_one_key(self):
|
||||
self.assertEqual({self.journal.identity(url) for url in REMOTES}, {"github.com/org/repo"})
|
||||
@@ -291,6 +295,18 @@ class TestScoreJournal(ScoreCase):
|
||||
self.assertEqual(len(done.stdout.splitlines()), 7)
|
||||
self.assertFalse(self.council.exists())
|
||||
|
||||
def test_a_missing_council_root_helper_is_named_in_the_one_stderr_line(self):
|
||||
script = self.copy_skills((SKILL / "labels.json").read_text(encoding="utf-8"))
|
||||
helper = self.tmp.resolve() / "skills" / "kvb-org-organize" / "scripts" / "councilroot.py"
|
||||
helper.unlink()
|
||||
for values, code in (({}, 0), ({"critical": "1"}, 4)):
|
||||
with self.subTest(values=values):
|
||||
done = self.score(script, *flags(values), "--message-block", cwd=self.tmp)
|
||||
self.assertEqual(done.returncode, code)
|
||||
self.assertEqual(done.stderr, f"score: journal: helper {helper} unusable (FileNotFoundError): install or update kvb-org-organize\n")
|
||||
self.assertEqual(len(done.stdout.splitlines()), 7)
|
||||
self.assertFalse(self.council.exists())
|
||||
|
||||
def test_a_branch_or_commit_outside_utf8_keeps_the_score_exit(self):
|
||||
repo = self.tmp / "latin"
|
||||
env = git_env(self.tmp)
|
||||
|
||||
Reference in new issue
Block a user