mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
Archive cleanup re-points the record and marks the worktree removed; a stale record is repaired at connect. A resumed session reattaches its own branch instead of cutting a new one.
154 lines
7.0 KiB
Python
154 lines
7.0 KiB
Python
"""`start_worktree` (Code coworker, 2026-11-07): the session moves into its feature
|
|
worktree — roots, shell cwd, persisted record — and cleanup on archive respects dirt.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from coworker.sessions import SessionRecord
|
|
from coworker.server.manager import SessionManager
|
|
from coworker.roots import RootDir
|
|
|
|
|
|
def _git(*args, cwd):
|
|
subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True, text=True)
|
|
|
|
|
|
@pytest.fixture
|
|
def repo(tmp_path) -> Path:
|
|
root = tmp_path / "proj"
|
|
root.mkdir()
|
|
_git("init", "-q", "-b", "main", cwd=root)
|
|
_git("config", "user.email", "t@example.com", cwd=root)
|
|
_git("config", "user.name", "Test User", cwd=root)
|
|
(root / "app.py").write_text("print('hi')\n", encoding="utf-8")
|
|
_git("add", ".", cwd=root)
|
|
_git("commit", "-q", "-m", "init", cwd=root)
|
|
return root
|
|
|
|
|
|
class _Shell:
|
|
"""The slice of an executor start_worktree touches: a cwd and a `cd` command."""
|
|
|
|
def __init__(self, cwd: str):
|
|
self.cwd = cwd
|
|
self.ran: list[str] = []
|
|
|
|
def run(self, command: str, timeout: int = 15):
|
|
self.ran.append(command)
|
|
if command.startswith("cd "):
|
|
self.cwd = command[3:].strip().strip("'")
|
|
return {"exit_code": 0, "stdout": "", "stderr": ""}
|
|
|
|
|
|
def _manager_with_session(tmp_path, repo, monkeypatch) -> tuple[SessionManager, str, SimpleNamespace]:
|
|
mgr = SessionManager(workspace=str(tmp_path), data_dir=tmp_path / "data")
|
|
sid = "sess-wt"
|
|
mgr.session_store.save(SessionRecord(session_id=sid, workspace=str(repo), model="m", mode="auto", agent="code"))
|
|
engine = SimpleNamespace(
|
|
executor=_Shell(str(repo)),
|
|
roots=[RootDir(path=repo.resolve(), writable=True, label="workspace")],
|
|
)
|
|
mgr._engines[sid] = engine
|
|
monkeypatch.setattr(mgr, "save", lambda *a, **k: None) # the real save needs a full engine
|
|
return mgr, sid, engine
|
|
|
|
|
|
def test_start_worktree_moves_the_session_in(tmp_path, repo, monkeypatch):
|
|
mgr, sid, engine = _manager_with_session(tmp_path, repo, monkeypatch)
|
|
res = mgr.start_worktree(sid, "add a login page")
|
|
assert res["ok"], res
|
|
path = Path(res["path"])
|
|
assert path == repo / ".openworker" / "worktrees" / "add-a-login-page"
|
|
assert res["branch"].endswith("/add-a-login-page")
|
|
# The shell moved, the worktree is the writable primary, the checkout went read-only.
|
|
assert Path(engine.executor.cwd).resolve() == path.resolve()
|
|
assert engine.roots[0].path == path.resolve() and engine.roots[0].writable
|
|
original = [r for r in engine.roots if Path(str(r.path)).resolve() == repo.resolve()]
|
|
assert original and original[0].writable is False
|
|
# Persisted on the record, and the engine is marked for the post-turn rebuild.
|
|
assert mgr.session_worktree(sid)["branch"] == res["branch"]
|
|
assert sid in mgr._promotion_rebuild
|
|
# A second call is a no-op that says so.
|
|
again = mgr.start_worktree(sid, "something else")
|
|
assert again["ok"] and again.get("already")
|
|
|
|
|
|
def test_start_worktree_refuses_a_plain_folder(tmp_path, monkeypatch):
|
|
plain = tmp_path / "plain"
|
|
plain.mkdir()
|
|
mgr, sid, engine = _manager_with_session(tmp_path, plain, monkeypatch)
|
|
res = mgr.start_worktree(sid, "anything")
|
|
assert not res["ok"] and "not a git repository" in res["error"]
|
|
assert engine.executor.cwd == str(plain) # nothing moved
|
|
|
|
|
|
def test_archive_removes_a_clean_worktree_but_keeps_a_dirty_one(tmp_path, repo, monkeypatch):
|
|
mgr, sid, engine = _manager_with_session(tmp_path, repo, monkeypatch)
|
|
res = mgr.start_worktree(sid, "cleanup check")
|
|
path = Path(res["path"])
|
|
(path / "wip.txt").write_text("unfinished", encoding="utf-8")
|
|
mgr.set_session_flags(sid, archived=True)
|
|
assert path.is_dir(), "a dirty worktree must survive archive"
|
|
(path / "wip.txt").unlink()
|
|
mgr.set_session_flags(sid, archived=False)
|
|
mgr.set_session_flags(sid, archived=True)
|
|
assert not path.exists()
|
|
# The branch is still there.
|
|
out = subprocess.run(["git", "branch", "--list", res["branch"]], cwd=repo, capture_output=True, text=True).stdout
|
|
assert res["branch"] in out
|
|
# The session lives in the repo root again (no "no valid workspace" loop on reopen),
|
|
# remembers its branch, and its engine was dropped so the next connect rebuilds.
|
|
record = mgr.session_store.load(sid)
|
|
assert Path(record.workspace) == repo
|
|
assert record.worktree["removed"] is True and record.worktree["branch"] == res["branch"]
|
|
assert sid not in mgr._engines
|
|
|
|
|
|
def test_a_resumed_session_gets_its_branch_back(tmp_path, repo, monkeypatch):
|
|
mgr, sid, engine = _manager_with_session(tmp_path, repo, monkeypatch)
|
|
first = mgr.start_worktree(sid, "resume me")
|
|
subprocess.run(["git", "commit", "-q", "--allow-empty", "-m", "wip"], cwd=first["path"], check=True)
|
|
mgr.set_session_flags(sid, archived=True)
|
|
assert not Path(first["path"]).exists()
|
|
# Back in the repo root; the next start_worktree reattaches the same branch.
|
|
mgr._engines[sid] = engine
|
|
engine.executor.cwd = str(repo)
|
|
again = mgr.start_worktree(sid, "something else entirely")
|
|
assert again["ok"] and again.get("reattached") and again["branch"] == first["branch"]
|
|
assert Path(again["path"]).is_dir()
|
|
log = subprocess.run(["git", "log", "--oneline", "-1"], cwd=again["path"], capture_output=True, text=True).stdout
|
|
assert "wip" in log
|
|
|
|
|
|
def test_connect_repairs_a_session_whose_worktree_folder_vanished(tmp_path, repo, monkeypatch):
|
|
mgr, sid, engine = _manager_with_session(tmp_path, repo, monkeypatch)
|
|
res = mgr.start_worktree(sid, "vanishing act")
|
|
subprocess.run(["git", "worktree", "remove", "--force", res["path"]], cwd=repo, check=True)
|
|
# The GUI asks for the folder it last knew; the server answers with the repo root.
|
|
assert Path(mgr.resolve_missing_worktree(sid, res["path"])) == repo
|
|
record = mgr.session_store.load(sid)
|
|
assert Path(record.workspace) == repo and record.worktree["removed"] is True
|
|
# An unrelated workspace request is left alone.
|
|
assert mgr.resolve_missing_worktree(sid, str(tmp_path)) == str(tmp_path)
|
|
|
|
|
|
def test_worktree_settings_round_trip_and_repo_override(tmp_path, repo):
|
|
mgr = SessionManager(workspace=str(tmp_path), data_dir=tmp_path / "data")
|
|
assert mgr.get_settings()["worktree_location"] == "in_repo"
|
|
bad = mgr.set_worktree_settings({"location": "moon"})
|
|
assert not bad["ok"]
|
|
ok = mgr.set_worktree_settings({"location": "sibling", "branch_prefix": "rp/", "prune_days": 30})
|
|
assert ok["ok"] and ok["worktree_location"] == "sibling" and ok["worktree_prune_days"] == 30
|
|
over = mgr.set_worktree_override(str(repo), {"location": "in_repo"})
|
|
assert over["ok"]
|
|
assert mgr.worktree_settings(str(repo)).location == "in_repo" # the repo's override wins
|
|
assert mgr.worktree_settings(str(tmp_path)).location == "sibling" # elsewhere, the global
|
|
cleared = mgr.set_worktree_override(str(repo), {})
|
|
assert cleared["ok"] and mgr.worktree_settings(str(repo)).location == "sibling"
|