feat: fold bot-bottle-orchestrator into bot_bottle/orchestrator subpackage
Moves the orchestrator into bot_bottle/orchestrator/ so one install gets everything. Entry point is now `python -m bot_bottle.orchestrator run`. - Add bot_bottle/orchestrator/ with all 14 modules (verbatim move; internal imports were already relative, so no changes inside orchestrator modules) - Rewrite bootstrap.py: remove the lazy bot_bottle import guard, use direct relative imports from ..contrib.* - Add bot_bottle/contrib/forge/base.py: ScopedForge (read-anywhere / write-scoped) - Add bot_bottle/contrib/gitea/client.py: GiteaClient + GiteaForge (urllib.request only) - Add bot_bottle/contrib/gitea/forge_state.py: ForgeState + SqliteForgeStateStore - Add tests/unit/orchestrator/ (82 tests: 63 migrated + 19 new for contrib modules) Closes #321
This commit is contained in:
@@ -0,0 +1,69 @@
|
||||
"""Shared test doubles: a duck-typed forge and bottle runner."""
|
||||
|
||||
# Test doubles mirror an API shape; some params are intentionally unused.
|
||||
# pylint: disable=unused-argument
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Sequence
|
||||
|
||||
from bot_bottle.orchestrator.runner import RunResult, slugify
|
||||
|
||||
|
||||
class FakeForge:
|
||||
def __init__(self, members: tuple[str, ...] = ()) -> None:
|
||||
self.members = set(members)
|
||||
self.comments: list[tuple[int, str]] = []
|
||||
self.descriptions: list[tuple[int, str]] = []
|
||||
self.scope_denied: set[int] = set()
|
||||
|
||||
def is_org_member(self, org: str, username: str) -> bool:
|
||||
return username in self.members
|
||||
|
||||
def read_issue(self, number: int) -> dict[str, object]:
|
||||
return {"number": number, "kind": "issue"}
|
||||
|
||||
def read_pr(self, number: int) -> dict[str, object]:
|
||||
return {"number": number, "merged": False}
|
||||
|
||||
def read_comments(self, number: int) -> list[dict[str, object]]:
|
||||
return [{"id": 1, "user": "alice", "body": "hi"}]
|
||||
|
||||
def post_comment(self, number: int, body: str) -> None:
|
||||
if number in self.scope_denied:
|
||||
raise PermissionError(f"write to #{number} denied")
|
||||
self.comments.append((number, body))
|
||||
|
||||
def update_description(self, number: int, body: str) -> None:
|
||||
if number in self.scope_denied:
|
||||
raise PermissionError(f"write to #{number} denied")
|
||||
self.descriptions.append((number, body))
|
||||
|
||||
|
||||
class FakeRunner:
|
||||
def __init__(self) -> None:
|
||||
self.calls: list[tuple[object, ...]] = []
|
||||
|
||||
def start(
|
||||
self,
|
||||
*,
|
||||
agent: str,
|
||||
bottles: Sequence[str],
|
||||
label: str,
|
||||
prompt: str,
|
||||
forge_env: dict[str, str],
|
||||
) -> RunResult:
|
||||
self.calls.append(("start", agent, tuple(bottles), label, prompt, dict(forge_env)))
|
||||
return RunResult(slug=slugify(label), exit_code=0)
|
||||
|
||||
def freeze(self, slug: str) -> int:
|
||||
self.calls.append(("freeze", slug))
|
||||
return 0
|
||||
|
||||
def resume(self, slug: str, prompt: str) -> RunResult:
|
||||
self.calls.append(("resume", slug, prompt))
|
||||
return RunResult(slug=slug, exit_code=0)
|
||||
|
||||
def destroy(self, slug: str) -> int:
|
||||
self.calls.append(("destroy", slug))
|
||||
return 0
|
||||
@@ -0,0 +1,38 @@
|
||||
"""Unit: Config.from_env."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
from bot_bottle.orchestrator.config import Config
|
||||
|
||||
|
||||
class ConfigTest(unittest.TestCase):
|
||||
def test_defaults(self):
|
||||
c = Config.from_env({"HOME": "/home/x"})
|
||||
self.assertEqual("bot-bottle", c.forge_org)
|
||||
self.assertEqual(1800, c.watchdog_timeout_secs)
|
||||
self.assertEqual("127.0.0.1", c.webhook_host)
|
||||
self.assertEqual(8477, c.webhook_port)
|
||||
self.assertEqual(Path("/home/x/.bot-bottle/forge-queue"), c.queue_dir)
|
||||
self.assertIsNone(c.db_path)
|
||||
|
||||
def test_overrides(self):
|
||||
c = Config.from_env({
|
||||
"HOME": "/home/x",
|
||||
"FORGE_ORG": "agents",
|
||||
"FORGE_WATCHDOG_TIMEOUT": "60",
|
||||
"FORGE_GITEA_API": "https://g.example/api/v1",
|
||||
"FORGE_WEBHOOK_PORT": "9000",
|
||||
"FORGE_DB_PATH": "/data/bb.db",
|
||||
})
|
||||
self.assertEqual("agents", c.forge_org)
|
||||
self.assertEqual(60, c.watchdog_timeout_secs)
|
||||
self.assertEqual("https://g.example/api/v1", c.gitea_api)
|
||||
self.assertEqual(9000, c.webhook_port)
|
||||
self.assertEqual(Path("/data/bb.db"), c.db_path)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,64 @@
|
||||
"""Unit: webhook payload parsing."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from bot_bottle.orchestrator.events import parse_event
|
||||
from bot_bottle.orchestrator.model import CommentCreated, IssueAssigned, PullRequestClosed
|
||||
|
||||
_REPO = {"repository": {"name": "bot-bottle", "owner": {"login": "didericis"}}}
|
||||
|
||||
|
||||
class ParseEventTest(unittest.TestCase):
|
||||
def test_issue_assigned(self):
|
||||
payload = {
|
||||
**_REPO,
|
||||
"action": "assigned",
|
||||
"issue": {
|
||||
"number": 17,
|
||||
"title": "Fix it",
|
||||
"body": "please",
|
||||
"assignees": [{"login": "agent-bot"}],
|
||||
"labels": [{"name": "bot-bottle:implementer"}],
|
||||
},
|
||||
}
|
||||
ev = parse_event("issues", payload)
|
||||
self.assertIsInstance(ev, IssueAssigned)
|
||||
assert isinstance(ev, IssueAssigned)
|
||||
self.assertEqual(("didericis", "bot-bottle", 17), (ev.owner, ev.repo, ev.issue_number))
|
||||
self.assertEqual(("agent-bot",), ev.assignees)
|
||||
self.assertEqual(("bot-bottle:implementer",), ev.labels)
|
||||
|
||||
def test_issue_non_assigned_ignored(self):
|
||||
self.assertIsNone(parse_event("issues", {**_REPO, "action": "opened", "issue": {}}))
|
||||
|
||||
def test_comment_created(self):
|
||||
payload = {
|
||||
**_REPO,
|
||||
"action": "created",
|
||||
"issue": {"number": 42, "pull_request": {"x": 1}},
|
||||
"comment": {"id": 5, "user": {"login": "reviewer"}, "body": "redo"},
|
||||
}
|
||||
ev = parse_event("issue_comment", payload)
|
||||
assert isinstance(ev, CommentCreated)
|
||||
self.assertEqual(42, ev.issue_number)
|
||||
self.assertEqual("reviewer", ev.author)
|
||||
self.assertTrue(ev.is_pull)
|
||||
|
||||
def test_pull_request_closed(self):
|
||||
payload = {**_REPO, "action": "closed", "pull_request": {"number": 8, "merged": True}}
|
||||
ev = parse_event("pull_request", payload)
|
||||
assert isinstance(ev, PullRequestClosed)
|
||||
self.assertEqual(8, ev.pr_number)
|
||||
self.assertTrue(ev.merged)
|
||||
|
||||
def test_pull_request_non_closed_ignored(self):
|
||||
self.assertIsNone(parse_event("pull_request", {**_REPO, "action": "opened"}))
|
||||
|
||||
def test_unknown_kind_ignored(self):
|
||||
self.assertIsNone(parse_event("push", {**_REPO}))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,75 @@
|
||||
"""Unit: ForgeState + SqliteForgeStateStore."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from bot_bottle.contrib.gitea.forge_state import ForgeState, SqliteForgeStateStore
|
||||
|
||||
|
||||
def _state(**kw: object) -> ForgeState:
|
||||
defaults: dict[str, object] = dict(
|
||||
owner="alice", repo="myrepo", issue_number=1,
|
||||
slug="impl-alice-myrepo-1", agent_name="impl",
|
||||
)
|
||||
defaults.update(kw)
|
||||
return ForgeState(**defaults) # type: ignore[arg-type]
|
||||
|
||||
|
||||
class ForgeStateStoreTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = SqliteForgeStateStore(None)
|
||||
|
||||
def test_upsert_and_get(self):
|
||||
s = _state()
|
||||
self.store.upsert(s)
|
||||
got = self.store.get("alice", "myrepo", 1)
|
||||
assert got is not None
|
||||
self.assertEqual("impl-alice-myrepo-1", got.slug)
|
||||
self.assertEqual("impl", got.agent_name)
|
||||
|
||||
def test_get_missing(self):
|
||||
self.assertIsNone(self.store.get("alice", "myrepo", 99))
|
||||
|
||||
def test_upsert_replaces(self):
|
||||
self.store.upsert(_state(status="running"))
|
||||
self.store.upsert(_state(status="frozen"))
|
||||
got = self.store.get("alice", "myrepo", 1)
|
||||
assert got is not None
|
||||
self.assertEqual("frozen", got.status)
|
||||
|
||||
def test_delete(self):
|
||||
self.store.upsert(_state())
|
||||
self.store.delete("alice", "myrepo", 1)
|
||||
self.assertIsNone(self.store.get("alice", "myrepo", 1))
|
||||
|
||||
def test_delete_missing_no_error(self):
|
||||
self.store.delete("alice", "myrepo", 99)
|
||||
|
||||
def test_all_sorted(self):
|
||||
self.store.upsert(_state(owner="z", issue_number=2))
|
||||
self.store.upsert(_state(owner="a", issue_number=1))
|
||||
rows = self.store.all()
|
||||
self.assertEqual(("a", "z"), (rows[0].owner, rows[1].owner))
|
||||
|
||||
def test_bottle_names_roundtrip(self):
|
||||
self.store.upsert(_state(bottle_names=["claude", "dev"]))
|
||||
got = self.store.get("alice", "myrepo", 1)
|
||||
assert got is not None
|
||||
self.assertEqual(["claude", "dev"], got.bottle_names)
|
||||
|
||||
def test_pr_number_none_roundtrip(self):
|
||||
self.store.upsert(_state(pr_number=None))
|
||||
got = self.store.get("alice", "myrepo", 1)
|
||||
assert got is not None
|
||||
self.assertIsNone(got.pr_number)
|
||||
|
||||
def test_pr_number_int_roundtrip(self):
|
||||
self.store.upsert(_state(pr_number=42))
|
||||
got = self.store.get("alice", "myrepo", 1)
|
||||
assert got is not None
|
||||
self.assertEqual(42, got.pr_number)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,140 @@
|
||||
"""Unit: the orchestration lifecycle."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
from typing import cast
|
||||
|
||||
from bot_bottle.orchestrator.lifecycle import Orchestrator
|
||||
from bot_bottle.orchestrator.model import (
|
||||
STATUS_FROZEN,
|
||||
STATUS_RUNNING,
|
||||
CommentCreated,
|
||||
IssueAssigned,
|
||||
PullRequestClosed,
|
||||
)
|
||||
from bot_bottle.orchestrator.store import InMemoryStateStore
|
||||
|
||||
from ._fakes import FakeForge, FakeRunner
|
||||
|
||||
|
||||
def _assigned(
|
||||
labels: tuple[str, ...] = ("bot-bottle:impl",),
|
||||
assignees: tuple[str, ...] = ("agent-bot",),
|
||||
) -> IssueAssigned:
|
||||
return IssueAssigned(
|
||||
owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
title="t", body="the task", assignees=tuple(assignees), labels=tuple(labels),
|
||||
)
|
||||
|
||||
|
||||
class LifecycleTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.forge = FakeForge(members=("agent-bot",))
|
||||
self.store = InMemoryStateStore()
|
||||
self.runner = FakeRunner()
|
||||
self.orch = Orchestrator(
|
||||
forge=self.forge, store=self.store, runner=self.runner,
|
||||
org="bot-bottle", gitea_api="https://g/api/v1",
|
||||
now=lambda: "2026-07-01T00:00:00-04:00",
|
||||
)
|
||||
|
||||
def _record(self):
|
||||
return self.store.get("didericis", "bot-bottle", 17)
|
||||
|
||||
def test_assigned_targeted_launches(self):
|
||||
self.orch.handle(_assigned())
|
||||
rec = self._record()
|
||||
assert rec is not None
|
||||
self.assertEqual(STATUS_RUNNING, rec.status)
|
||||
self.assertEqual("impl-didericis-bot-bottle-17", rec.slug)
|
||||
self.assertEqual("start", self.runner.calls[0][0])
|
||||
# forge context injected into the child env.
|
||||
env = cast("dict[str, str]", self.runner.calls[0][5])
|
||||
self.assertEqual("didericis", env["FORGE_OWNER"])
|
||||
self.assertEqual("17", env["FORGE_ISSUE_NUMBER"])
|
||||
|
||||
def test_untargeted_ignored(self):
|
||||
self.orch.handle(_assigned(labels=("bug",)))
|
||||
self.assertIsNone(self._record())
|
||||
self.assertEqual([], self.runner.calls)
|
||||
|
||||
def test_assigned_is_idempotent(self):
|
||||
self.orch.handle(_assigned())
|
||||
self.orch.handle(_assigned()) # redelivery
|
||||
starts = [c for c in self.runner.calls if c[0] == "start"]
|
||||
self.assertEqual(1, len(starts))
|
||||
|
||||
def test_done_signal_freezes(self):
|
||||
self.orch.handle(_assigned())
|
||||
self.orch.on_done_signal("didericis", "bot-bottle", 17, "success", "done")
|
||||
rec = self._record()
|
||||
assert rec is not None
|
||||
self.assertEqual(STATUS_FROZEN, rec.status)
|
||||
self.assertIn(("freeze", "impl-didericis-bot-bottle-17"), self.runner.calls)
|
||||
|
||||
def test_done_signal_ignored_when_not_running(self):
|
||||
# No record yet -> no freeze.
|
||||
self.orch.on_done_signal("didericis", "bot-bottle", 17, "s", "")
|
||||
self.assertEqual([], self.runner.calls)
|
||||
|
||||
def test_comment_on_frozen_resumes(self):
|
||||
self.orch.handle(_assigned())
|
||||
self.orch.on_done_signal("didericis", "bot-bottle", 17, "s", "")
|
||||
self.orch.handle(CommentCreated(
|
||||
owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
comment_id=1, author="reviewer", body="please redo", is_pull=False,
|
||||
))
|
||||
rec = self._record()
|
||||
assert rec is not None
|
||||
self.assertEqual(STATUS_RUNNING, rec.status)
|
||||
self.assertIn(("resume", "impl-didericis-bot-bottle-17", "please redo"),
|
||||
self.runner.calls)
|
||||
|
||||
def test_comment_echo_guard(self):
|
||||
self.orch.handle(_assigned())
|
||||
self.orch.on_done_signal("didericis", "bot-bottle", 17, "s", "")
|
||||
rec = self._record()
|
||||
assert rec is not None
|
||||
rec.agent_git_user = "agent-bot"
|
||||
self.store.upsert(rec)
|
||||
self.orch.handle(CommentCreated(
|
||||
owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
comment_id=2, author="agent-bot", body="I finished", is_pull=False,
|
||||
))
|
||||
# Still frozen, no resume triggered by the agent's own comment.
|
||||
self.assertEqual(STATUS_FROZEN, self._record().status) # type: ignore[union-attr]
|
||||
self.assertNotIn("resume", [c[0] for c in self.runner.calls])
|
||||
|
||||
def test_comment_on_running_ignored(self):
|
||||
self.orch.handle(_assigned()) # running
|
||||
self.orch.handle(CommentCreated(
|
||||
owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
comment_id=1, author="reviewer", body="hi", is_pull=False,
|
||||
))
|
||||
self.assertNotIn("resume", [c[0] for c in self.runner.calls])
|
||||
|
||||
def test_pr_comment_routes_via_link(self):
|
||||
self.orch.handle(_assigned())
|
||||
self.orch.on_done_signal("didericis", "bot-bottle", 17, "s", "")
|
||||
self.orch.link_pr("didericis", "bot-bottle", 17, 42)
|
||||
# Comment arrives on PR #42 (issue_number == PR number in Gitea).
|
||||
self.orch.handle(CommentCreated(
|
||||
owner="didericis", repo="bot-bottle", issue_number=42,
|
||||
comment_id=9, author="reviewer", body="fix", is_pull=True,
|
||||
))
|
||||
self.assertIn(("resume", "impl-didericis-bot-bottle-17", "fix"),
|
||||
self.runner.calls)
|
||||
|
||||
def test_pr_closed_destroys_and_removes(self):
|
||||
self.orch.handle(_assigned())
|
||||
self.orch.link_pr("didericis", "bot-bottle", 17, 42)
|
||||
self.orch.handle(PullRequestClosed(
|
||||
owner="didericis", repo="bot-bottle", pr_number=42, merged=True,
|
||||
))
|
||||
self.assertIn(("destroy", "impl-didericis-bot-bottle-17"), self.runner.calls)
|
||||
self.assertIsNone(self._record())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,53 @@
|
||||
"""Unit: provenance assembly + serialization."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from bot_bottle.orchestrator.model import RunRecord
|
||||
from bot_bottle.orchestrator.provenance import build_provenance, ops_from_log, provenance_to_dict
|
||||
|
||||
|
||||
def _record() -> RunRecord:
|
||||
return RunRecord(
|
||||
owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
slug="impl-17", agent_name="impl", bottle_names=["claude"],
|
||||
last_checkin_at="2026-07-01T00:05:00-04:00",
|
||||
)
|
||||
|
||||
|
||||
class ProvenanceTest(unittest.TestCase):
|
||||
def test_ops_from_log(self):
|
||||
ops = ops_from_log([
|
||||
{"at": "T1", "op": "read_pr", "target": 5, "detail": "ok"},
|
||||
{"at": "T2", "op": "signal_done", "target": None, "detail": "success: done"},
|
||||
])
|
||||
self.assertEqual(2, len(ops))
|
||||
self.assertEqual("read_pr", ops[0].op)
|
||||
self.assertIsNone(ops[1].target)
|
||||
|
||||
def test_build_and_serialize(self):
|
||||
ops = ops_from_log([{"at": "T1", "op": "post_comment", "target": 17, "detail": "ok"}])
|
||||
prov = build_provenance(
|
||||
_record(), ops=ops, started_at="2026-07-01T00:00:00-04:00",
|
||||
finished_at="2026-07-01T00:05:00-04:00", exit_code=0, watchdog_fired=False,
|
||||
)
|
||||
d = provenance_to_dict(prov)
|
||||
self.assertEqual("impl-17", d["slug"])
|
||||
self.assertEqual("didericis", d["owner"])
|
||||
self.assertEqual(["claude"], d["bottles"])
|
||||
self.assertEqual(0, d["exit_code"])
|
||||
self.assertFalse(d["watchdog_fired"])
|
||||
self.assertEqual(1, len(d["ops"]))
|
||||
self.assertEqual("post_comment", d["ops"][0]["op"])
|
||||
|
||||
def test_watchdog_flag_serialized(self):
|
||||
prov = build_provenance(
|
||||
_record(), ops=(), started_at="", finished_at="",
|
||||
exit_code=None, watchdog_fired=True,
|
||||
)
|
||||
self.assertTrue(provenance_to_dict(prov)["watchdog_fired"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,65 @@
|
||||
"""Unit: SubprocessBottleRunner + slugify (injected run fn)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
from collections.abc import Sequence
|
||||
|
||||
from bot_bottle.orchestrator.runner import SubprocessBottleRunner, slugify
|
||||
|
||||
|
||||
class SlugifyTest(unittest.TestCase):
|
||||
def test_basic(self):
|
||||
self.assertEqual("impl-didericis-bot-bottle-17",
|
||||
slugify("impl-didericis-bot-bottle-17"))
|
||||
|
||||
def test_collapses_and_strips(self):
|
||||
self.assertEqual("a-b-c", slugify(" A_B/C!! "))
|
||||
|
||||
|
||||
class SubprocessRunnerTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.argvs: list[list[str]] = []
|
||||
self.envs: list[dict[str, str]] = []
|
||||
|
||||
def fake_run(argv: Sequence[str], env: dict[str, str]) -> int:
|
||||
self.argvs.append(list(argv))
|
||||
self.envs.append(dict(env))
|
||||
return 0
|
||||
|
||||
self.runner = SubprocessBottleRunner(
|
||||
cli="/x/cli.py", base_env={"PATH": "/bin"}, python="/py", run=fake_run
|
||||
)
|
||||
|
||||
def test_start_argv_and_env(self):
|
||||
result = self.runner.start(
|
||||
agent="impl", bottles=["claude", "dev"], label="impl-r-17",
|
||||
prompt="do it", forge_env={"FORGE_OWNER": "didericis"},
|
||||
)
|
||||
self.assertEqual("impl-r-17", result.slug)
|
||||
argv = self.argvs[0]
|
||||
self.assertEqual(["/py", "/x/cli.py", "start", "impl", "--headless",
|
||||
"--label", "impl-r-17", "--prompt", "do it",
|
||||
"--bottle", "claude", "--bottle", "dev"], argv)
|
||||
# forge_env merged over base_env for the child.
|
||||
self.assertEqual("didericis", self.envs[0]["FORGE_OWNER"])
|
||||
self.assertEqual("/bin", self.envs[0]["PATH"])
|
||||
|
||||
def test_start_no_bottles_omits_flag(self):
|
||||
self.runner.start(agent="impl", bottles=[], label="l", prompt="p", forge_env={})
|
||||
self.assertNotIn("--bottle", self.argvs[0])
|
||||
|
||||
def test_freeze_calls_commit(self):
|
||||
self.runner.freeze("slug-1")
|
||||
self.assertEqual(["/py", "/x/cli.py", "commit", "slug-1"], self.argvs[0])
|
||||
|
||||
def test_resume_headless(self):
|
||||
r = self.runner.resume("slug-1", "address review")
|
||||
self.assertEqual("slug-1", r.slug)
|
||||
self.assertEqual(
|
||||
["/py", "/x/cli.py", "resume", "slug-1", "--headless", "--prompt",
|
||||
"address review"], self.argvs[0])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,75 @@
|
||||
"""Unit: ScopedForge — read-anywhere / write-scoped access control."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from bot_bottle.contrib.forge.base import ScopedForge
|
||||
|
||||
from ._fakes import FakeForge
|
||||
|
||||
|
||||
class ScopedForgeTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.inner = FakeForge()
|
||||
self.scoped = ScopedForge(
|
||||
self.inner, assigned_issue=10, assigned_prs=[20, 30]
|
||||
)
|
||||
|
||||
# --- reads always pass through -----------------------------------------
|
||||
|
||||
def test_read_issue_allowed_anywhere(self):
|
||||
for number in (10, 20, 99):
|
||||
result = self.scoped.read_issue(number)
|
||||
self.assertEqual(number, result["number"])
|
||||
|
||||
def test_read_pr_allowed_anywhere(self):
|
||||
for number in (10, 20, 99):
|
||||
result = self.scoped.read_pr(number)
|
||||
self.assertEqual(number, result["number"])
|
||||
|
||||
def test_read_comments_allowed_anywhere(self):
|
||||
comments = self.scoped.read_comments(99)
|
||||
self.assertTrue(len(comments) > 0)
|
||||
|
||||
def test_is_org_member_passes_through(self):
|
||||
inner = FakeForge(members=("alice",))
|
||||
scoped = ScopedForge(inner, assigned_issue=1, assigned_prs=[])
|
||||
self.assertTrue(scoped.is_org_member("org", "alice"))
|
||||
self.assertFalse(scoped.is_org_member("org", "bob"))
|
||||
|
||||
# --- writes: assigned numbers allowed ----------------------------------
|
||||
|
||||
def test_post_comment_on_assigned_issue(self):
|
||||
self.scoped.post_comment(10, "hi")
|
||||
self.assertIn((10, "hi"), self.inner.comments)
|
||||
|
||||
def test_post_comment_on_assigned_pr(self):
|
||||
self.scoped.post_comment(20, "lgtm")
|
||||
self.assertIn((20, "lgtm"), self.inner.comments)
|
||||
|
||||
def test_update_description_on_assigned(self):
|
||||
self.scoped.update_description(30, "updated")
|
||||
self.assertIn((30, "updated"), self.inner.descriptions)
|
||||
|
||||
# --- writes: unassigned numbers denied ---------------------------------
|
||||
|
||||
def test_post_comment_denied_for_unassigned(self):
|
||||
with self.assertRaises(PermissionError):
|
||||
self.scoped.post_comment(99, "nope")
|
||||
self.assertEqual([], self.inner.comments)
|
||||
|
||||
def test_update_description_denied_for_unassigned(self):
|
||||
with self.assertRaises(PermissionError):
|
||||
self.scoped.update_description(99, "nope")
|
||||
self.assertEqual([], self.inner.descriptions)
|
||||
|
||||
def test_error_message_names_number(self):
|
||||
try:
|
||||
self.scoped.post_comment(99, "nope")
|
||||
except PermissionError as exc:
|
||||
self.assertIn("99", str(exc))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,108 @@
|
||||
"""Unit: forge sidecar dispatch, op log, queue relay, socket server."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import socket
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
from bot_bottle.orchestrator.sidecar import (
|
||||
ForgeSidecar,
|
||||
OpLog,
|
||||
drain_done_events,
|
||||
serve,
|
||||
write_done_event,
|
||||
)
|
||||
|
||||
from ._fakes import FakeForge
|
||||
|
||||
|
||||
class SidecarDispatchTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = Path(self.enterContext(tempfile.TemporaryDirectory())) # pylint: disable=consider-using-with
|
||||
self.forge = FakeForge()
|
||||
self.log = OpLog(self.tmp / "ops.jsonl", now=lambda: "T")
|
||||
self.queue = self.tmp / "queue"
|
||||
self.sc = ForgeSidecar(
|
||||
forge=self.forge, op_log=self.log, queue_dir=self.queue,
|
||||
run_key=("o", "r", 17),
|
||||
)
|
||||
|
||||
def test_read_pr_ok_and_logged(self):
|
||||
resp = self.sc.dispatch("read_pr", {"number": 5})
|
||||
self.assertTrue(resp["ok"])
|
||||
self.assertEqual(5, resp["result"]["number"])
|
||||
self.assertEqual([("read_pr", 5, "ok")],
|
||||
[(o["op"], o["target"], o["detail"]) for o in self.log.read()])
|
||||
|
||||
def test_post_comment_writes_and_logs(self):
|
||||
resp = self.sc.dispatch("post_comment", {"number": 17, "body": "done"})
|
||||
self.assertTrue(resp["ok"])
|
||||
self.assertEqual([(17, "done")], self.forge.comments)
|
||||
|
||||
def test_scope_denied_write_returns_error_and_audits_rejection(self):
|
||||
self.forge.scope_denied.add(999)
|
||||
resp = self.sc.dispatch("post_comment", {"number": 999, "body": "x"})
|
||||
self.assertFalse(resp["ok"])
|
||||
self.assertIn("denied", resp["error"])
|
||||
# The rejection is recorded in the op log, not just the allows.
|
||||
self.assertIn("error", self.log.read()[-1]["detail"])
|
||||
self.assertEqual([], self.forge.comments)
|
||||
|
||||
def test_signal_done_queues_event(self):
|
||||
resp = self.sc.dispatch("signal_done", {"status": "success", "summary": "ok"})
|
||||
self.assertTrue(resp["ok"])
|
||||
events = drain_done_events(self.queue)
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual(("o", "r", 17, "success"),
|
||||
(events[0]["owner"], events[0]["repo"],
|
||||
events[0]["issue_number"], events[0]["status"]))
|
||||
|
||||
def test_unknown_method(self):
|
||||
resp = self.sc.dispatch("delete_repo", {})
|
||||
self.assertFalse(resp["ok"])
|
||||
|
||||
|
||||
class QueueTest(unittest.TestCase):
|
||||
def test_drain_removes_events(self):
|
||||
tmp = Path(self.enterContext(tempfile.TemporaryDirectory())) # pylint: disable=consider-using-with
|
||||
write_done_event(tmp, {"owner": "o", "repo": "r", "issue_number": 1})
|
||||
self.assertEqual(1, len(drain_done_events(tmp)))
|
||||
self.assertEqual([], drain_done_events(tmp)) # drained
|
||||
|
||||
def test_drain_missing_dir(self):
|
||||
self.assertEqual([], drain_done_events(Path("/nonexistent/queue")))
|
||||
|
||||
|
||||
class SocketServerTest(unittest.TestCase):
|
||||
def test_round_trip_over_unix_socket(self):
|
||||
tmp = tempfile.mkdtemp()
|
||||
sock = Path(tmp) / "s.sock"
|
||||
if len(str(sock)) > 100: # AF_UNIX path limit; skip on long tmp paths
|
||||
self.skipTest("temp socket path too long for AF_UNIX")
|
||||
sidecar = ForgeSidecar(
|
||||
forge=FakeForge(), op_log=OpLog(Path(tmp) / "ops.jsonl"),
|
||||
queue_dir=Path(tmp) / "q", run_key=("o", "r", 1),
|
||||
)
|
||||
srv = serve(sidecar, sock)
|
||||
t = threading.Thread(target=srv.handle_request, daemon=True)
|
||||
t.start()
|
||||
try:
|
||||
client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
||||
client.connect(str(sock))
|
||||
client.sendall(b'{"method": "read_issue", "params": {"number": 3}}\n')
|
||||
line = client.makefile().readline()
|
||||
client.close()
|
||||
finally:
|
||||
t.join(timeout=5)
|
||||
srv.server_close()
|
||||
resp = json.loads(line)
|
||||
self.assertTrue(resp["ok"])
|
||||
self.assertEqual(3, resp["result"]["number"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,50 @@
|
||||
"""Unit: InMemoryStateStore."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from bot_bottle.orchestrator.model import RunRecord
|
||||
from bot_bottle.orchestrator.store import InMemoryStateStore
|
||||
|
||||
|
||||
def _rec(issue: int, owner: str = "o") -> RunRecord:
|
||||
return RunRecord(owner=owner, repo="r", issue_number=issue, slug=f"s{issue}",
|
||||
agent_name="a")
|
||||
|
||||
|
||||
class InMemoryStoreTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = InMemoryStateStore()
|
||||
|
||||
def test_upsert_get(self):
|
||||
self.store.upsert(_rec(1))
|
||||
got = self.store.get("o", "r", 1)
|
||||
assert got is not None
|
||||
self.assertEqual("s1", got.slug)
|
||||
|
||||
def test_get_missing(self):
|
||||
self.assertIsNone(self.store.get("o", "r", 99))
|
||||
|
||||
def test_upsert_replaces(self):
|
||||
self.store.upsert(_rec(1))
|
||||
r = _rec(1)
|
||||
r.slug = "changed"
|
||||
self.store.upsert(r)
|
||||
self.assertEqual("changed", self.store.get("o", "r", 1).slug) # type: ignore[union-attr]
|
||||
self.assertEqual(1, len(self.store.all()))
|
||||
|
||||
def test_delete(self):
|
||||
self.store.upsert(_rec(1))
|
||||
self.store.delete("o", "r", 1)
|
||||
self.assertIsNone(self.store.get("o", "r", 1))
|
||||
|
||||
def test_all_sorted(self):
|
||||
self.store.upsert(_rec(2, owner="b"))
|
||||
self.store.upsert(_rec(1, owner="a"))
|
||||
self.assertEqual([("a", 1), ("b", 2)],
|
||||
[(r.owner, r.issue_number) for r in self.store.all()])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,60 @@
|
||||
"""Unit: targeting (labels + org membership)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
|
||||
from bot_bottle.orchestrator.model import IssueAssigned
|
||||
from bot_bottle.orchestrator.targeting import parse_labels, resolve_target
|
||||
|
||||
from ._fakes import FakeForge
|
||||
|
||||
|
||||
def _issue(
|
||||
assignees: tuple[str, ...] = ("agent-bot",),
|
||||
labels: tuple[str, ...] = ("bot-bottle:implementer",),
|
||||
) -> IssueAssigned:
|
||||
return IssueAssigned(
|
||||
owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
title="t", body="b", assignees=tuple(assignees), labels=tuple(labels),
|
||||
)
|
||||
|
||||
|
||||
class ParseLabelsTest(unittest.TestCase):
|
||||
def test_agent_label(self):
|
||||
self.assertEqual(("implementer", None), parse_labels(("bot-bottle:implementer",)))
|
||||
|
||||
def test_bottle_override_not_confused_with_agent(self):
|
||||
agent, bottle = parse_labels(("bot-bottle:impl", "bot-bottle-bottle:dev"))
|
||||
self.assertEqual(("impl", "dev"), (agent, bottle))
|
||||
|
||||
def test_no_agent_label(self):
|
||||
self.assertEqual((None, None), parse_labels(("bug", "p1")))
|
||||
|
||||
|
||||
class ResolveTargetTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.forge = FakeForge(members=("agent-bot",))
|
||||
|
||||
def test_targeted(self):
|
||||
target = resolve_target(_issue(), self.forge, "bot-bottle")
|
||||
assert target is not None
|
||||
self.assertEqual("implementer", target.agent_name)
|
||||
self.assertIsNone(target.bottle_override)
|
||||
|
||||
def test_bottle_override(self):
|
||||
ev = _issue(labels=("bot-bottle:impl", "bot-bottle-bottle:dev"))
|
||||
target = resolve_target(ev, self.forge, "bot-bottle")
|
||||
assert target is not None
|
||||
self.assertEqual("dev", target.bottle_override)
|
||||
|
||||
def test_no_label_not_targeted(self):
|
||||
self.assertIsNone(resolve_target(_issue(labels=("bug",)), self.forge, "bot-bottle"))
|
||||
|
||||
def test_non_member_assignee_not_targeted(self):
|
||||
ev = _issue(assignees=("random-user",))
|
||||
self.assertIsNone(resolve_target(ev, self.forge, "bot-bottle"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,66 @@
|
||||
"""Unit: watchdog sweep."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import unittest
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
from bot_bottle.orchestrator.model import STATUS_FROZEN, STATUS_RUNNING, RunRecord
|
||||
from bot_bottle.orchestrator.store import InMemoryStateStore
|
||||
from bot_bottle.orchestrator.watchdog import Watchdog
|
||||
|
||||
from ._fakes import FakeRunner
|
||||
|
||||
_NOW = datetime(2026, 7, 1, 12, 0, 0).astimezone()
|
||||
|
||||
|
||||
def _record(issue: int, status: str, checkin: str) -> RunRecord:
|
||||
return RunRecord(
|
||||
owner="o", repo="r", issue_number=issue, slug=f"s{issue}",
|
||||
agent_name="a", status=status, last_checkin_at=checkin,
|
||||
)
|
||||
|
||||
|
||||
class WatchdogSweepTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = InMemoryStateStore()
|
||||
self.runner = FakeRunner()
|
||||
self.wd = Watchdog(store=self.store, runner=self.runner, timeout_secs=1800)
|
||||
|
||||
def _status(self, issue: int) -> str:
|
||||
rec = self.store.get("o", "r", issue)
|
||||
assert rec is not None
|
||||
return rec.status
|
||||
|
||||
def test_stale_running_is_frozen(self):
|
||||
stale = (_NOW - timedelta(minutes=31)).isoformat()
|
||||
self.store.upsert(_record(1, STATUS_RUNNING, stale))
|
||||
fired = self.wd.sweep(_NOW)
|
||||
self.assertEqual([1], [r.issue_number for r in fired])
|
||||
self.assertEqual(STATUS_FROZEN, self._status(1))
|
||||
self.assertIn(("freeze", "s1"), self.runner.calls)
|
||||
|
||||
def test_fresh_running_untouched(self):
|
||||
fresh = (_NOW - timedelta(minutes=5)).isoformat()
|
||||
self.store.upsert(_record(2, STATUS_RUNNING, fresh))
|
||||
self.assertEqual([], self.wd.sweep(_NOW))
|
||||
self.assertEqual(STATUS_RUNNING, self._status(2))
|
||||
|
||||
def test_non_running_ignored(self):
|
||||
stale = (_NOW - timedelta(hours=2)).isoformat()
|
||||
self.store.upsert(_record(3, STATUS_FROZEN, stale))
|
||||
self.assertEqual([], self.wd.sweep(_NOW))
|
||||
|
||||
def test_unparseable_checkin_skipped(self):
|
||||
self.store.upsert(_record(4, STATUS_RUNNING, "not-a-time"))
|
||||
self.assertEqual([], self.wd.sweep(_NOW))
|
||||
|
||||
def test_start_and_stop(self):
|
||||
# Exercises the daemon-thread start/stop path; stop sets the event
|
||||
# so the loop's wait returns immediately.
|
||||
self.wd.start()
|
||||
self.wd.stop()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,155 @@
|
||||
"""Unit: webhook HTTP surface (signature + routing over a real server)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import threading
|
||||
import unittest
|
||||
import urllib.request
|
||||
from urllib.error import HTTPError
|
||||
|
||||
from bot_bottle.orchestrator.model import RunRecord
|
||||
from bot_bottle.orchestrator.store import InMemoryStateStore
|
||||
from bot_bottle.orchestrator.webhook import WebhookServer, verify_signature
|
||||
|
||||
_ISSUE_ASSIGNED = {
|
||||
"action": "assigned",
|
||||
"repository": {"name": "bot-bottle", "owner": {"login": "didericis"}},
|
||||
"issue": {
|
||||
"number": 17, "title": "t", "body": "b",
|
||||
"assignees": [{"login": "agent-bot"}],
|
||||
"labels": [{"name": "bot-bottle:impl"}],
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
class _RecordingOrch:
|
||||
def __init__(self) -> None:
|
||||
self.events: list[object] = []
|
||||
|
||||
def handle(self, event: object) -> None:
|
||||
self.events.append(event)
|
||||
|
||||
|
||||
class SignatureTest(unittest.TestCase):
|
||||
def test_verify(self):
|
||||
secret = b"s3cret"
|
||||
body = b'{"x":1}'
|
||||
sig = hmac.new(secret, body, hashlib.sha256).hexdigest()
|
||||
self.assertTrue(verify_signature(secret, body, sig))
|
||||
self.assertFalse(verify_signature(secret, body, "deadbeef"))
|
||||
|
||||
|
||||
class WebhookServerTest(unittest.TestCase):
|
||||
# _serve is the per-test setup; attributes are assigned there.
|
||||
# pylint: disable=attribute-defined-outside-init
|
||||
def _serve(self, **kwargs: object) -> None:
|
||||
self.orch = _RecordingOrch()
|
||||
kwargs.setdefault("store", InMemoryStateStore())
|
||||
self.server = WebhookServer(
|
||||
("127.0.0.1", 0), orchestrator=self.orch, **kwargs, # type: ignore[arg-type]
|
||||
)
|
||||
self.port = self.server.server_address[1]
|
||||
self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
|
||||
self.thread.start()
|
||||
self.addCleanup(self._shutdown)
|
||||
|
||||
def _shutdown(self) -> None:
|
||||
self.server.shutdown()
|
||||
self.server.server_close()
|
||||
self.thread.join(timeout=5)
|
||||
|
||||
def _post(
|
||||
self, path: str, body: bytes, headers: dict[str, str] | None = None
|
||||
) -> tuple[int, dict[str, object]]:
|
||||
req = urllib.request.Request(
|
||||
f"http://127.0.0.1:{self.port}{path}", data=body, method="POST",
|
||||
headers=headers or {},
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=5) as resp:
|
||||
return resp.status, json.loads(resp.read())
|
||||
|
||||
def _get(self, path: str) -> tuple[int, dict[str, object]]:
|
||||
with urllib.request.urlopen(f"http://127.0.0.1:{self.port}{path}", timeout=5) as r:
|
||||
return r.status, json.loads(r.read())
|
||||
|
||||
def test_webhook_dispatches(self):
|
||||
self._serve()
|
||||
body = json.dumps(_ISSUE_ASSIGNED).encode()
|
||||
status, payload = self._post("/webhook", body, {"X-Gitea-Event": "issues"})
|
||||
self.assertEqual(200, status)
|
||||
self.assertTrue(payload["handled"])
|
||||
self.assertEqual(1, len(self.orch.events))
|
||||
|
||||
def test_unhandled_event_ok_but_not_handled(self):
|
||||
self._serve()
|
||||
body = json.dumps({"action": "push"}).encode()
|
||||
_status, payload = self._post("/webhook", body, {"X-Gitea-Event": "push"})
|
||||
self.assertFalse(payload["handled"])
|
||||
self.assertEqual([], self.orch.events)
|
||||
|
||||
def test_invalid_json_400(self):
|
||||
self._serve()
|
||||
with self.assertRaises(HTTPError) as ctx:
|
||||
self._post("/webhook", b"{not json", {"X-Gitea-Event": "issues"})
|
||||
self.assertEqual(400, ctx.exception.code)
|
||||
|
||||
def test_bad_signature_rejected(self):
|
||||
self._serve(secret=b"sekret")
|
||||
body = json.dumps(_ISSUE_ASSIGNED).encode()
|
||||
with self.assertRaises(HTTPError) as ctx:
|
||||
self._post("/webhook", body,
|
||||
{"X-Gitea-Event": "issues", "X-Gitea-Signature": "deadbeef"})
|
||||
self.assertEqual(401, ctx.exception.code)
|
||||
self.assertEqual([], self.orch.events)
|
||||
|
||||
def test_good_signature_accepted(self):
|
||||
self._serve(secret=b"sekret")
|
||||
body = json.dumps(_ISSUE_ASSIGNED).encode()
|
||||
sig = hmac.new(b"sekret", body, hashlib.sha256).hexdigest()
|
||||
status, _payload = self._post(
|
||||
"/webhook", body, {"X-Gitea-Event": "issues", "X-Gitea-Signature": sig})
|
||||
self.assertEqual(200, status)
|
||||
self.assertEqual(1, len(self.orch.events))
|
||||
|
||||
def test_healthz(self):
|
||||
self._serve()
|
||||
self.assertEqual(200, self._get("/healthz")[0])
|
||||
|
||||
def test_unknown_path_404(self):
|
||||
self._serve()
|
||||
with self.assertRaises(HTTPError) as ctx:
|
||||
self._post("/nope", b"{}", {"X-Gitea-Event": "issues"})
|
||||
self.assertEqual(404, ctx.exception.code)
|
||||
|
||||
def test_provenance_returns_record_and_ops(self):
|
||||
store = InMemoryStateStore()
|
||||
store.upsert(RunRecord(owner="didericis", repo="bot-bottle", issue_number=17,
|
||||
slug="impl-17", agent_name="impl", bottle_names=["claude"]))
|
||||
|
||||
def reader(rec: object) -> list[dict[str, object]]: # pylint: disable=unused-argument
|
||||
return [{"at": "T", "op": "post_comment", "target": 17, "detail": "ok"}]
|
||||
|
||||
self._serve(store=store, op_log_reader=reader)
|
||||
status, payload = self._get("/provenance?owner=didericis&repo=bot-bottle&issue=17")
|
||||
self.assertEqual(200, status)
|
||||
self.assertEqual("impl-17", payload["slug"])
|
||||
self.assertEqual(1, len(payload["ops"])) # type: ignore[arg-type]
|
||||
|
||||
def test_provenance_missing_params_400(self):
|
||||
self._serve()
|
||||
with self.assertRaises(HTTPError) as ctx:
|
||||
self._get("/provenance?owner=didericis")
|
||||
self.assertEqual(400, ctx.exception.code)
|
||||
|
||||
def test_provenance_unknown_run_404(self):
|
||||
self._serve()
|
||||
with self.assertRaises(HTTPError) as ctx:
|
||||
self._get("/provenance?owner=x&repo=y&issue=1")
|
||||
self.assertEqual(404, ctx.exception.code)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user