Files
claude-config/bin/do_epic/test_repos.py
T

190 lines
9.4 KiB
Python

import pathlib
import sys
import tempfile
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from test_env import assert_not_root
from do_epic.config import DoEpicConfig
from failure import Failure
from do_epic.repos import locate, Located, Unsure
from project_config.settings import ProjectConfig
from project_config.doubles import write_config
class FakeGit:
"""git as locate calls it: origins maps a checkout to its origin URL, cloned holds each `clone` that worked, and refused names a URL whose clone fails after it made the checkout's `.git`, as a stopped git does. Where locked, that clone also takes away the right to remove what it made."""
def __init__(self, origins: dict[str, str | Failure], refused: str | None = None, locked: bool = False) -> None:
self.origins, self.refused, self.locked = origins, refused, locked
self.cloned: list[tuple[str, str]] = []
self.clone_timeouts: list[float | None] = []
self.clone_options: list[tuple[str, ...]] = []
def __call__(self, *args: str, cwd: str | None = None, timeout: float | None = None, guarded: bool = False, errors: str = "strict") -> str | Failure:
if args[:3] == ("remote", "get-url", "origin"):
return self.origins[cwd or ""]
clone = args.index("clone")
self.clone_options.append(args[:clone])
assert args[clone + 1] == "--", args
url, destination = args[clone + 2:clone + 4]
pathlib.Path(destination, ".git").mkdir(parents=True)
if url == self.refused:
if self.locked:
pathlib.Path(destination).chmod(0o500)
return Failure("git clone: repository not found")
self.cloned.append((url, destination))
self.clone_timeouts.append(timeout)
return ""
class LocateTest(unittest.TestCase):
def setUp(self) -> None:
made = tempfile.TemporaryDirectory()
self.addCleanup(made.cleanup)
self.home = pathlib.Path(made.name).resolve()
self.projects = self.home / ".claude-projects"
self.config = DoEpicConfig(self.projects / "do-epic", "https://acme.atlassian.net", self.home / "jira.env", self.home / "clones", "English", "claude-opus-5-5", "rule")
self.billing, self.payments = self.home / "elsewhere" / "billing", self.home / "elsewhere" / "payments"
self.origins: dict[str, str | Failure] = {str(self.billing): "git@github.com:acme/billing.git", str(self.payments): "git@github.com:acme/payments"}
def configure(self) -> None:
write_config(self.home, self.home / "code" / "ledger")
def locate(self, git: FakeGit, name: str = "ledger") -> Located | Failure:
return locate(name, [self.billing, self.payments], self.config, self.home, git)
def unsure(self, git: FakeGit, name: str = "ledger") -> str:
found = self.locate(git, name)
assert isinstance(found, Unsure), found
return found.reason
def test_finds_a_checkout_that_exists_with_its_config_and_clones_nothing(self) -> None:
self.configure()
(self.home / "code" / "ledger" / ".git").mkdir(parents=True)
git = FakeGit(self.origins)
found = self.locate(git)
assert isinstance(found, Located), found
self.assertEqual((found.checkout, found.config.folder, git.cloned), (self.home / "code" / "ledger", self.projects / "ledger", []))
def test_clones_a_checkout_the_config_names_where_it_is_missing_from_the_place_of_the_other_repos(self) -> None:
self.configure()
git = FakeGit(self.origins)
found = self.locate(git)
assert isinstance(found, Located), found
self.assertEqual((found.checkout, git.cloned), (self.home / "code" / "ledger", [("git@github.com:acme/ledger", str(self.home / "code" / "ledger"))]))
assert isinstance(found.config, ProjectConfig)
def test_clones_into_the_clone_folder_and_asks_for_a_config_where_none_names_the_repo(self) -> None:
git = FakeGit(self.origins)
asked = self.unsure(git)
clone = self.home / "clones" / "ledger"
self.assertEqual(git.cloned, [("git@github.com:acme/ledger", str(clone))])
self.assertIn(f"{clone} was cloned, but no project config names it", asked)
self.assertIn(f"{self.projects}/<key>/config.toml with `checkout = \"{clone}\"`", asked)
self.assertEqual(self.unsure(git), asked.replace("was cloned", "holds the repo"), "the second ask finds the clone and clones nothing")
self.assertEqual(len(git.cloned), 1)
def test_asks_where_the_other_repos_sit_in_more_than_one_place(self) -> None:
self.configure()
self.origins[str(self.payments)] = "git@gitea.larvit.se:acme/payments"
git = FakeGit(self.origins)
asked = self.unsure(git)
self.assertIn("git@gitea.larvit.se:acme/ledger or git@github.com:acme/ledger", asked)
self.assertEqual(git.cloned, [])
def test_asks_where_the_other_repos_differ_only_by_owner(self) -> None:
self.configure()
self.origins[str(self.payments)] = "git@github.com:other/payments"
self.assertIn("more than one host or owner", self.unsure(FakeGit(self.origins)))
def test_asks_where_no_other_repo_shows_where_to_clone_from(self) -> None:
self.configure()
found = locate("ledger", [], self.config, self.home, FakeGit({}))
assert isinstance(found, Unsure), found
self.assertIn("no other repo of the epic", found.reason)
def test_asks_where_an_others_origin_cannot_be_read_or_has_no_place(self) -> None:
self.configure()
self.origins[str(self.billing)] = Failure("git remote: no such remote 'origin'")
self.assertIn(f"cannot read the origin of {self.billing}: git remote: no such remote 'origin'", self.unsure(FakeGit(self.origins)))
self.origins[str(self.billing)] = "billing"
self.assertIn(f"{self.billing} has an origin, billing, with no host and owner to put another repo under", self.unsure(FakeGit(self.origins)))
def test_asks_all_the_same_where_the_leftovers_of_a_failed_clone_cannot_be_removed(self) -> None:
assert_not_root(self)
self.configure()
left = self.home / "code" / "ledger"
self.addCleanup(lambda: left.chmod(0o700))
self.assertIn("cannot clone", self.unsure(FakeGit(self.origins, refused="git@github.com:acme/ledger", locked=True)))
self.assertTrue((left / ".git").is_dir())
def test_asks_where_the_clone_fails_naming_the_url_and_the_reason(self) -> None:
self.configure()
asked = self.unsure(FakeGit(self.origins, refused="git@github.com:acme/ledger"))
self.assertIn(f"cannot clone git@github.com:acme/ledger to {self.home / 'code' / 'ledger'}: git clone: repository not found", asked)
def test_asks_where_the_place_to_clone_into_holds_something_that_is_not_a_checkout(self) -> None:
self.configure()
(self.home / "code" / "ledger").mkdir(parents=True)
(self.home / "code" / "ledger" / "notes.txt").write_text("x", encoding="utf-8")
git = FakeGit(self.origins)
self.assertIn(f"{self.home / 'code' / 'ledger'} exists and is not a git checkout", self.unsure(git))
self.assertEqual(git.cloned, [])
def test_refuses_a_name_that_is_not_a_repo_name_before_it_forms_a_path_or_a_command(self) -> None:
for name in ("../escape", "-flag", "a/b", ""):
with self.subTest(name=name):
found = self.locate(FakeGit(self.origins), name)
assert isinstance(found, Failure) and not isinstance(found, Unsure), found
self.assertIn("is not a repo's name", found.reason)
def test_refuses_an_origin_that_is_not_https_ssh_or_an_scp_style_address(self) -> None:
self.configure()
for origin in ("ext::sh -c touch% x/billing", "file:///srv/acme/billing", "/srv/acme/billing", "-oProxy=x:a/b"):
with self.subTest(origin=origin):
self.origins[str(self.billing)] = origin
self.origins[str(self.payments)] = origin
git = FakeGit(self.origins)
self.assertIn("is not an https, ssh or scp-style address", self.unsure(git))
self.assertEqual(git.cloned, [])
def test_clones_and_asks_without_the_credentials_an_origin_holds(self) -> None:
self.configure()
self.origins[str(self.billing)] = "https://bot:s3cret@gitea.larvit.se/acme/billing"
self.origins[str(self.payments)] = "https://other:t0@ken@gitea.larvit.se/acme/payments.git"
git = FakeGit(self.origins)
self.assertIsInstance(self.locate(git), Located)
self.assertEqual(git.cloned, [("https://gitea.larvit.se/acme/ledger", str(self.home / "code" / "ledger"))])
self.origins[str(self.payments)] = "https://other:t0@ken@gitea.larvit.se/acme/payments"
self.origins[str(self.billing)] = "https://bot:s3cret@gitea.larvit.se"
self.assertNotIn("s3cret", self.unsure(FakeGit(self.origins), "stock"))
def test_stops_a_clone_that_waits_and_makes_a_prompt_fail(self) -> None:
self.configure()
git = FakeGit(self.origins)
self.locate(git)
self.assertEqual(git.clone_timeouts, [600])
self.assertEqual(git.clone_options, [("-c", "core.askPass=true", "-c", "core.sshCommand=ssh -o BatchMode=yes")])
def test_removes_what_a_failed_clone_began_so_that_the_next_run_clones_again(self) -> None:
self.configure()
failing = FakeGit(self.origins, refused="git@github.com:acme/ledger")
self.unsure(failing)
self.assertFalse((self.home / "code" / "ledger").exists())
found = self.locate(FakeGit(self.origins))
self.assertIsInstance(found, Located)
def test_asks_where_the_place_to_clone_into_is_a_file(self) -> None:
self.configure()
(self.home / "code").mkdir()
(self.home / "code" / "ledger").write_text("x", encoding="utf-8")
self.assertIn("exists and is not a git checkout", self.unsure(FakeGit(self.origins)))
def test_fails_with_the_config_failure_where_a_config_cannot_be_read(self) -> None:
(self.projects / "broken").mkdir(parents=True)
(self.projects / "broken" / "config.toml").write_text("this is not toml", encoding="utf-8")
found = self.locate(FakeGit(self.origins))
self.assertIsInstance(found, Failure)
self.assertNotIsInstance(found, Unsure)