190 lines
9.4 KiB
Python
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)
|