repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
nushell/tests/test_git_wt.py
Raw"""End-to-end contract tests for the native ``git wt`` Nushell namespace.
Every repository, hook, approval, fake forge client, and Git configuration used
here lives below the OS temporary directory. These tests intentionally execute
no network operation: remote refs are local Git fixture refs and forge clients
are deterministic local Python programs.
"""
from __future__ import annotations
import json
import os
from pathlib import Path
import shutil
import stat
import subprocess
import sys
import tempfile
import unittest
NU_DIR = Path(__file__).resolve().parents[1]
MODULE = NU_DIR / "modules" / "git.nu"
GIT = shutil.which("git")
def native_nu() -> str | None:
"""Avoid a version-manager shim after HOME is isolated for each fixture."""
if os.name == "nt":
candidate = Path(os.environ.get("ProgramFiles", r"C:\\Program Files")) / "nu" / "bin" / "nu.exe"
if candidate.is_file():
return str(candidate)
return shutil.which("nu")
NU = native_nu()
def nu_literal(value: object) -> str:
"""Return a Nu raw string literal for an arbitrary fixture path/value."""
text = str(value)
hashes = "#"
while f"'{hashes}" in text:
hashes += "#"
return f"r{hashes}'{text}'{hashes}"
class GitWtIntegration(unittest.TestCase):
"""Contract coverage for ordinary clones and bare-root repositories."""
maxDiff = None
@classmethod
def setUpClass(cls):
if not NU or not GIT:
raise unittest.SkipTest("Nu and Git are required")
parent = Path(tempfile.gettempdir()) / "pi-nu-wt-tests"
parent.mkdir(parents=True, exist_ok=True)
cls._temporary = tempfile.TemporaryDirectory(prefix="native-", dir=parent)
cls.parent = Path(cls._temporary.name)
@classmethod
def tearDownClass(cls):
cls._temporary.cleanup()
def setUp(self):
self.case = Path(tempfile.mkdtemp(prefix=f"{self._testMethodName}-", dir=self.parent))
self.home = self.case / "home"
self.home.mkdir()
self.bin = self.case / "bin"
self.bin.mkdir()
self.config = self.case / "personal-wt.nuon"
self.config.write_text("{}\n", encoding="utf-8")
self.approvals = self.case / "approvals.nuon"
self.global_config = self.case / "empty-global.gitconfig"
self.global_config.write_text("", encoding="utf-8")
self.system_config = self.case / "empty-system.gitconfig"
self.system_config.write_text("", encoding="utf-8")
self.template = self.case / "empty-template"
self.template.mkdir()
self.log = self.case / "fake-forge.log"
self.environment = os.environ.copy()
for key in list(self.environment):
if key.lower() in {"home", "userprofile", "xdg_config_home", "xdg_data_home"}:
self.environment.pop(key)
self.environment.update(
HOME=str(self.home),
USERPROFILE=str(self.home),
XDG_CONFIG_HOME=str(self.home / "config"),
XDG_DATA_HOME=str(self.home / "data"),
GIT_CONFIG_NOSYSTEM="1",
GIT_CONFIG_GLOBAL=str(self.global_config),
GIT_CONFIG_SYSTEM=str(self.system_config),
GIT_TEMPLATE_DIR=str(self.template),
NU_WT_CONFIG=str(self.config),
NU_WT_APPROVALS=str(self.approvals),
WT_FAKE_LOG=str(self.log),
)
path_key = next((key for key in self.environment if key.lower() == "path"), "PATH")
self.environment[path_key] = str(self.bin) + os.pathsep + self.environment.get(path_key, "")
self._write_forge_fixtures()
def tearDown(self):
shutil.rmtree(self.case, ignore_errors=True)
def git(self, *args: object, cwd: Path | None = None, check: bool = True):
result = subprocess.run(
[GIT, *map(str, args)],
cwd=cwd,
env=self.environment,
capture_output=True,
encoding="utf-8",
timeout=30,
check=False,
)
if check:
self.assertEqual(
0,
result.returncode,
f"git {' '.join(map(str, args))}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}",
)
return result
def configure_identity(self, repo: Path):
self.git("config", "user.name", "Native WT Test", cwd=repo)
self.git("config", "user.email", "native-wt@example.invalid", cwd=repo)
self.git("config", "commit.gpgsign", "false", cwd=repo)
self.git("config", "core.hooksPath", str(self.template), cwd=repo)
def commit(self, repo: Path, name: str, content: str, message: str):
(repo / name).parent.mkdir(parents=True, exist_ok=True)
(repo / name).write_text(content, encoding="utf-8")
self.git("add", name, cwd=repo)
self.git("commit", "-m", message, cwd=repo)
def ordinary_clone(self) -> tuple[Path, Path]:
"""Return an ordinary clone plus its local bare remote fixture."""
seed = self.case / "seed"
remote = self.case / "origin.git"
repo = self.case / "ordinary clone"
self.git("init", "-b", "trunk", seed)
self.configure_identity(seed)
self.commit(seed, "README.md", "base\n", "base")
self.git("init", "--bare", "--initial-branch=trunk", remote)
self.git("remote", "add", "origin", str(remote), cwd=seed)
self.git("push", "-u", "origin", "trunk", cwd=seed)
self.git("clone", str(remote), repo)
self.configure_identity(repo)
return repo, remote
def bare_layout(self) -> tuple[Path, Path]:
"""Return a bare directory and primary worktree beside it."""
seed = self.case / "seed"
remote = self.case / "origin.git"
root = self.case / "bare root"
bare = root / "project.git"
primary = root / "trunk"
self.git("init", "-b", "trunk", seed)
self.configure_identity(seed)
self.commit(seed, "README.md", "base\n", "base")
self.git("init", "--bare", "--initial-branch=trunk", remote)
self.git("remote", "add", "origin", str(remote), cwd=seed)
self.git("push", "-u", "origin", "trunk", cwd=seed)
root.mkdir()
self.git("clone", "--bare", str(remote), bare)
self.git("worktree", "add", primary, "trunk", cwd=bare)
self.configure_identity(primary)
return bare, primary
def nu(self, code: str, *, cwd: Path, timeout: int = 90, environment=None):
"""Run one isolated Nu process using the public module namespace."""
result = subprocess.run(
[NU, "--no-config-file", "-c", f"$env.config.error_style = 'plain'; use {nu_literal(MODULE)}; cd {nu_literal(cwd)}; {code}"],
# Nu's logical cd does not release its Windows startup-directory handle.
cwd=self.case,
env=self.environment if environment is None else environment,
capture_output=True,
encoding="utf-8",
timeout=timeout,
check=False,
)
return result
def wt_json(self, invocation: str, *, cwd: Path):
result = self.nu(
"let result = (" + invocation + "); {result: $result, cwd: (pwd)} | to json",
cwd=cwd,
)
self.assertEqual(
0,
result.returncode,
f"{invocation}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}",
)
self.assertNotIn("deprecated", result.stderr.lower())
return json.loads(result.stdout)
def wt_fails(self, invocation: str, *, cwd: Path, contains: str | None = None, environment=None):
result = self.nu(invocation, cwd=cwd, environment=environment)
self.assertNotEqual(0, result.returncode, f"unexpected success: {invocation}")
if contains:
self.assertIn(contains.lower(), (result.stdout + result.stderr).lower(),
f"{invocation}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}")
return result
def branch_exists(self, repo: Path, branch: str) -> bool:
return self.git("show-ref", "--verify", "--quiet", f"refs/heads/{branch}", cwd=repo, check=False).returncode == 0
def worktree_path(self, repo: Path, branch: str) -> Path | None:
output = self.git("worktree", "list", "--porcelain", cwd=repo).stdout.splitlines()
path = None
for line in output:
if line.startswith("worktree "):
path = Path(line.removeprefix("worktree "))
elif line == f"branch refs/heads/{branch}":
return path
return None
def write_project_hooks(self, repo: Path, events: dict[str, list[list[str]]]):
config = repo / ".config" / "nu-wt.nuon"
config.parent.mkdir(parents=True, exist_ok=True)
# JSON is valid NUON data, keeps command values literal and cross-platform.
config.write_text(json.dumps({"hooks": events}) + "\n", encoding="utf-8")
def _write_forge_fixtures(self):
program = self.bin / "forge_fixture.py"
program.write_text(
"import json, os, pathlib, sys\n"
"pathlib.Path(os.environ['WT_FAKE_LOG']).parent.mkdir(parents=True, exist_ok=True)\n"
"with open(os.environ['WT_FAKE_LOG'], 'a', encoding='utf-8') as f:\n"
" f.write(sys.argv[1] + ' ' + json.dumps(sys.argv[2:]) + '\\n')\n"
"name = sys.argv[1]\n"
"args = sys.argv[2:]\n"
"mode = os.environ.get('WT_FAKE_MODE', 'ok')\n"
"if mode == 'failure':\n"
" print('fixture authentication failure', file=sys.stderr); sys.exit(17)\n"
"if mode == 'malformed':\n"
" print('unexpected provider output'); sys.exit(0)\n"
"if name == 'gh' and 'list' in args:\n"
" print(json.dumps([{'number': 17, 'title': 'Fixture PR', 'headRefName': 'pr-branch'}]))\n"
"elif name == 'fj':\n"
" print('#17 Fixture PR (by fixture)')\n"
"sys.exit(0)\n",
encoding="utf-8",
)
if os.name == "nt":
for name in ("gh", "fj"):
(self.bin / f"{name}.cmd").write_text(
f'@"{sys.executable}" "{program}" {name} %*\r\n', encoding="utf-8"
)
else:
for name in ("gh", "fj"):
launcher = self.bin / name
launcher.write_text(
f"#!{sys.executable}\n"
"import runpy, sys\n"
f"sys.argv.insert(1, {name!r})\n"
f"runpy.run_path({str(program)!r}, run_name='__main__')\n",
encoding="utf-8",
)
launcher.chmod(launcher.stat().st_mode | stat.S_IXUSR)
def test_list_and_status_are_structured_for_ordinary_clone(self):
repo, _ = self.ordinary_clone()
self.git("worktree", "add", "-b", "feature", self.case / "external feature", cwd=repo)
feature = self.case / "external feature"
(feature / "dirty.txt").write_text("dirty\n", encoding="utf-8")
listed = self.wt_json("git wt list", cwd=repo)["result"]
self.assertIsInstance(listed, list)
by_branch = {row["branch"]: row for row in listed}
self.assertEqual(str(repo.resolve()), by_branch["trunk"]["path"])
self.assertTrue(by_branch["trunk"]["current"])
self.assertTrue(by_branch["feature"]["dirty"])
self.assertIn("locked", by_branch["feature"])
default = self.wt_json("git wt", cwd=repo)["result"]
self.assertEqual(listed, default)
fast = self.wt_json("git wt list --fast", cwd=repo)["result"]
self.assertEqual({row["branch"] for row in listed}, {row["branch"] for row in fast})
self.assertTrue(all("dirty" not in row for row in fast), fast)
def test_bare_root_lists_and_creates_worktrees_beside_bare_directory(self):
bare, primary = self.bare_layout()
self.git('config', 'wt.main-branch', 'trunk', cwd=bare)
self.git('symbolic-ref', 'HEAD', 'refs/heads/unborn', cwd=bare)
listed = self.wt_json("git wt list", cwd=primary)["result"]
self.assertEqual(["trunk"], [row["branch"] for row in listed])
self.assertEqual(str(primary.resolve()), listed[0]["path"])
self.assertTrue(listed[0]['primary'])
self.wt_fails('git wt remove trunk --keep-branch', cwd=primary, contains='primary')
switched = self.wt_json("git wt switch --create feature --base trunk", cwd=primary)
feature = bare.parent / "feature"
self.assertEqual(str(feature.resolve()), switched["cwd"])
self.assertTrue(feature.is_dir())
self.assertEqual(feature.resolve(), self.worktree_path(primary, "feature").resolve())
def test_switch_existing_arbitrary_path_and_new_local_branch_change_cwd(self):
repo, _ = self.ordinary_clone()
arbitrary = self.case / "outside" / "quoted existing worktree"
arbitrary.parent.mkdir()
self.git("worktree", "add", "-b", "existing", arbitrary, cwd=repo)
existing = self.wt_json("git wt switch existing", cwd=repo)
self.assertEqual(str(arbitrary.resolve()), existing["cwd"])
by_path = self.wt_json(f"git wt switch {nu_literal(arbitrary)}", cwd=repo)
self.assertEqual(str(arbitrary.resolve()), by_path["cwd"])
created = self.wt_json("git wt switch --create nested/topic --base trunk", cwd=repo)
expected = repo.parent / f"{repo.name}.worktrees" / "nested" / "topic"
self.assertEqual(str(expected.resolve()), created["cwd"])
self.assertTrue((expected / ".git").exists())
def test_switch_remote_disambiguation_and_noninteractive_picker_refusal(self):
repo, _ = self.ordinary_clone()
self.git("branch", "topic", cwd=repo)
tip = self.git("rev-parse", "trunk", cwd=repo).stdout.strip()
self.git("update-ref", "refs/remotes/origin/topic", tip, cwd=repo)
self.git("update-ref", "refs/remotes/origin/remote-only", tip, cwd=repo)
self.wt_fails("git wt switch topic", cwd=repo, contains="ambiguous")
self.wt_fails("git wt switch", cwd=repo, contains="interactive")
switched = self.wt_json("git wt switch origin/remote-only", cwd=repo)
expected = repo.parent / f"{repo.name}.worktrees" / "remote-only"
self.assertEqual(str(expected.resolve()), switched["cwd"])
self.assertTrue(self.branch_exists(repo, "remote-only"))
def test_path_mapping_rejects_collision_traversal_reserved_and_case_collision(self):
repo, _ = self.ordinary_clone()
destination = repo.parent / f"{repo.name}.worktrees" / "occupied"
destination.mkdir(parents=True)
marker = destination / "must-survive"
marker.write_text("do not delete", encoding="utf-8")
self.wt_fails("git wt switch --create occupied --base trunk", cwd=repo, contains="occupied")
self.assertEqual("do not delete", marker.read_text(encoding="utf-8"))
self.wt_fails("git wt switch --create ../escape --base trunk", cwd=repo, contains="travers")
self.wt_fails("git wt switch --create CON --base trunk", cwd=repo, contains="reserved")
self.wt_json("git wt switch --create CaseName --base trunk", cwd=repo)
self.wt_fails("git wt switch --create casename --base trunk", cwd=repo, contains="case")
def test_remove_refuses_dirty_locked_primary_and_nested_registered_worktrees(self):
repo, _ = self.ordinary_clone()
dirty = self.case / "dirty"
self.git("worktree", "add", "-b", "dirty", dirty, cwd=repo)
(dirty / "uncommitted").write_text("x", encoding="utf-8")
self.wt_fails("git wt remove dirty", cwd=repo, contains="dirty")
self.assertTrue(dirty.exists())
locked = self.case / "locked"
self.git("worktree", "add", "-b", "locked", locked, cwd=repo)
self.git("worktree", "lock", locked, cwd=repo)
self.wt_fails("git wt remove locked", cwd=repo, contains="locked")
self.assertTrue(locked.exists())
self.wt_fails("git wt remove trunk", cwd=repo, contains="primary")
parent = self.case / "nested parent"
child = parent / "child"
self.git("worktree", "add", "-b", "nested-parent", parent, cwd=repo)
self.git("worktree", "add", "-b", "nested-child", child, cwd=repo)
self.wt_fails("git wt remove nested-parent", cwd=repo, contains="nested")
self.assertTrue(parent.exists())
def test_default_branch_uses_remote_head_with_slash_remote_name(self):
repo, remote = self.ordinary_clone()
source = self.case / 'integrated into release'
self.git('worktree', 'add', '-b', 'completed', source, cwd=repo)
self.commit(source, 'completed.txt', 'done\n', 'completed')
tip = self.git('rev-parse', 'HEAD', cwd=source).stdout.strip()
self.git('branch', 'release', tip, cwd=repo)
self.git('remote', 'add', 'up/stream', str(remote), cwd=repo)
self.git('update-ref', 'refs/remotes/up/stream/release', tip, cwd=repo)
self.git('symbolic-ref', 'refs/remotes/up/stream/HEAD', 'refs/remotes/up/stream/release', cwd=repo)
self.git('symbolic-ref', '--delete', 'refs/remotes/origin/HEAD', cwd=repo)
self.wt_json('git wt remove completed', cwd=repo)
self.assertFalse(source.exists())
self.assertFalse(self.branch_exists(repo, 'completed'))
self.assertEqual(tip, self.git('rev-parse', 'release', cwd=repo).stdout.strip())
def test_remove_keep_branch_and_integrated_cleanup_change_current_directory(self):
repo, _ = self.ordinary_clone()
kept = self.case / "kept"
self.git("worktree", "add", "-b", "kept", kept, cwd=repo)
removed = self.wt_json("git wt remove kept --keep-branch", cwd=repo)
self.assertEqual(str(repo.resolve()), removed["cwd"])
self.assertFalse(kept.exists())
self.assertTrue(self.branch_exists(repo, "kept"))
integrated = self.case / "integrated"
self.git("worktree", "add", "-b", "integrated", integrated, cwd=repo)
self.commit(integrated, "integrated.txt", "ok\n", "integrated")
self.git("merge", "--ff-only", "integrated", cwd=repo)
cleaned = self.wt_json("git wt remove integrated", cwd=integrated)
self.assertEqual(str(repo.resolve()), cleaned["cwd"])
self.assertFalse(integrated.exists())
self.assertFalse(self.branch_exists(repo, "integrated"))
def test_project_hook_approval_invalidation_and_literal_launch_argv(self):
repo, _ = self.ordinary_clone()
recorder = self.case / "record.py"
hook_log = self.case / "hook argv.json"
launch_log = self.case / "launch argv.json"
recorder.write_text(
"import json, os, pathlib, sys\n"
"pathlib.Path(sys.argv[1]).write_text(json.dumps({'argv': sys.argv[2:], 'cwd': os.getcwd(), 'repo': os.environ.get('WT_REPO')}), encoding='utf-8')\n",
encoding="utf-8",
)
self.write_project_hooks(
repo,
{"post-create": [[sys.executable, str(recorder), str(hook_log), "hook; literal", "$(not-shell)", ""]]},
)
self.git("add", ".config/nu-wt.nuon", cwd=repo)
self.git("commit", "-m", "configure hooks", cwd=repo)
unapproved = repo.parent / f"{repo.name}.worktrees" / "unapproved"
self.wt_fails("git wt switch --create unapproved --base trunk", cwd=repo, contains="approval")
self.assertTrue(unapproved.exists(), "declined project-hook approval preserves created data")
approved = self.wt_json("git wt switch --create approved --base trunk --approve-hooks", cwd=repo)
approved_path = Path(approved["cwd"])
hook = json.loads(hook_log.read_text(encoding="utf-8"))
self.assertEqual(["hook; literal", "$(not-shell)", ""], hook["argv"])
self.assertEqual(str(approved_path), hook["cwd"])
# Exact command content is trusted, not an event-wide blanket approval.
self.write_project_hooks(
approved_path,
{"post-create": [[sys.executable, str(recorder), str(hook_log), "changed"]]},
)
self.wt_fails("git wt hook post-create", cwd=approved_path, contains="approval")
launched = self.wt_json(
"git wt switch approved --execute "
+ nu_literal(sys.executable)
+ " "
+ nu_literal(recorder)
+ " "
+ nu_literal(launch_log)
+ " "
+ nu_literal("arg; still literal")
+ " "
+ nu_literal("$(also-not-shell)"),
cwd=repo,
)
self.assertEqual(str(approved_path), launched["cwd"])
launch = json.loads(launch_log.read_text(encoding="utf-8"))
self.assertEqual(["arg; still literal", "$(also-not-shell)"], launch["argv"])
def test_switch_keeps_created_worktree_when_post_create_hook_or_launch_fails(self):
repo, _ = self.ordinary_clone()
failer = self.case / "fail.py"
failer.write_text("import sys\nsys.exit(23)\n", encoding="utf-8")
self.write_project_hooks(repo, {"post-create": [[sys.executable, str(failer)]]})
self.git("add", ".config/nu-wt.nuon", cwd=repo)
self.git("commit", "-m", "failing create hook", cwd=repo)
created = repo.parent / f"{repo.name}.worktrees" / "hook-fails"
self.wt_fails("git wt switch --create hook-fails --base trunk --approve-hooks", cwd=repo, contains="hook")
self.assertTrue(created.exists(), "failed post-create must preserve new worktree")
self.assertTrue(self.branch_exists(repo, "hook-fails"))
self.write_project_hooks(repo, {"post-create": []})
self.git("add", ".config/nu-wt.nuon", cwd=repo)
self.git("commit", "-m", "disable hook", cwd=repo)
launch = repo.parent / f"{repo.name}.worktrees" / "launch-fails"
self.wt_fails(
"git wt switch --create launch-fails --base trunk --execute " + nu_literal(sys.executable) + " -c " + nu_literal("import sys; sys.exit(29)"),
cwd=repo,
contains="launch",
)
self.assertTrue(launch.exists(), "failed launch must preserve new worktree")
self.assertTrue(self.branch_exists(repo, "launch-fails"))
def test_merge_squashes_rebases_updates_target_and_keeps_recovery_ref(self):
repo, _ = self.ordinary_clone()
source = self.case / "source"
self.git("worktree", "add", "-b", "feature", source, cwd=repo)
self.commit(source, "feature-one.txt", "one\n", "feature one")
self.commit(source, "feature-two.txt", "two\n", "feature two")
old_source_tip = self.git("rev-parse", "feature", cwd=repo).stdout.strip()
self.commit(repo, "target.txt", "target\n", "target moved")
merged = self.wt_json("git wt merge trunk --message 'integrate feature'", cwd=source)
self.assertEqual(str(repo.resolve()), merged["cwd"])
self.assertFalse(source.exists())
self.assertFalse(self.branch_exists(repo, "feature"))
self.assertEqual("target\n", (repo / "target.txt").read_text(encoding="utf-8"))
self.assertEqual("one\n", (repo / "feature-one.txt").read_text(encoding="utf-8"))
subjects = self.git("log", "trunk", "--format=%s", cwd=repo).stdout.splitlines()
self.assertEqual("integrate feature", subjects[0])
recovery = self.git("for-each-ref", "--contains", old_source_tip, "--format=%(refname)", cwd=repo).stdout.splitlines()
self.assertTrue(recovery, "rewritten source tip needs a recovery ref")
def test_merge_refuses_dirty_source_and_target_without_history_changes(self):
repo, _ = self.ordinary_clone()
source = self.case / 'dirty-merge-source'
self.git('worktree', 'add', '-b', 'dirty-merge', source, cwd=repo)
self.commit(source, 'feature.txt', 'feature\n', 'feature')
source_tip = self.git('rev-parse', 'HEAD', cwd=source).stdout.strip()
target_tip = self.git('rev-parse', 'HEAD', cwd=repo).stdout.strip()
dirty_source = source / 'unfinished.txt'
dirty_source.write_text('do not stage or discard', encoding='utf-8')
self.wt_fails('git wt merge trunk', cwd=source, contains='dirty worktree')
self.assertEqual('do not stage or discard', dirty_source.read_text(encoding='utf-8'))
dirty_source.unlink()
dirty_target = repo / 'unfinished-target.txt'
dirty_target.write_text('keep target', encoding='utf-8')
self.wt_fails('git wt merge trunk', cwd=source, contains='dirty worktree')
self.assertEqual('keep target', dirty_target.read_text(encoding='utf-8'))
self.assertEqual(source_tip, self.git('rev-parse', 'HEAD', cwd=source).stdout.strip())
self.assertEqual(target_tip, self.git('rev-parse', 'HEAD', cwd=repo).stdout.strip())
self.assertEqual('', self.git('for-each-ref', '--format=%(refname)', 'refs/wt/recovery/', cwd=repo).stdout.strip())
def test_merge_keep_retains_source_worktree_and_branch(self):
repo, _ = self.ordinary_clone()
source = self.case / "keep source"
self.git("worktree", "add", "-b", "keep-source", source, cwd=repo)
self.commit(source, "keep.txt", "keep\n", "keep source")
merged = self.wt_json("git wt merge trunk --message 'keep source' --keep", cwd=source)
self.assertEqual(str(source.resolve()), merged["cwd"])
self.assertEqual("keep\n", (repo / "keep.txt").read_text(encoding="utf-8"))
self.assertTrue(source.exists())
self.assertTrue(self.branch_exists(repo, "keep-source"))
def test_merge_conflict_and_pre_merge_hook_failure_preserve_source_worktree(self):
repo, _ = self.ordinary_clone()
source = self.case / "conflict source"
self.git("worktree", "add", "-b", "conflict", source, cwd=repo)
self.commit(source, "README.md", "source\n", "source edit")
self.commit(repo, "README.md", "target\n", "target edit")
self.wt_fails("git wt merge trunk --message conflict", cwd=source, contains="conflict")
self.assertTrue(source.exists())
self.assertTrue(self.branch_exists(repo, "conflict"))
self.assertNotEqual("", self.git("status", "--porcelain", cwd=source).stdout)
self.git("rebase", "--abort", cwd=source, check=False)
self.git("reset", "--hard", "trunk", cwd=source)
self.commit(source, "hook.txt", "x\n", "hook candidate")
failer = self.case / "pre_merge_fails.py"
failer.write_text("import sys\nsys.exit(41)\n", encoding="utf-8")
self.write_project_hooks(source, {"pre-merge": [[sys.executable, str(failer)]]})
self.git("add", ".config/nu-wt.nuon", cwd=source)
self.git("commit", "-m", "configure pre-merge check", cwd=source)
self.wt_fails("git wt merge trunk --message hook --approve-hooks", cwd=source, contains="hook failed")
self.assertTrue(source.exists())
self.assertTrue(self.branch_exists(repo, "conflict"))
def test_merge_rebase_cannot_auto_approve_new_hook_content(self):
repo, _ = self.ordinary_clone()
marker = self.case / 'unexpected-hook'
writer = self.case / 'write-marker.py'
writer.write_text('import pathlib, sys\npathlib.Path(sys.argv[1]).write_text("ran")\n', encoding='utf-8')
self.write_project_hooks(repo, {'pre-merge': [[sys.executable, '-c', 'pass']]})
self.git('add', '.config/nu-wt.nuon', cwd=repo)
self.git('commit', '-m', 'initial approved command', cwd=repo)
source = self.case / 'hook-change-source'
self.git('worktree', 'add', '-b', 'hook-change', source, cwd=repo)
self.commit(source, 'feature.txt', 'feature\n', 'feature')
self.write_project_hooks(repo, {'pre-merge': [[sys.executable, str(writer), str(marker)]]})
self.git('add', '.config/nu-wt.nuon', cwd=repo)
self.git('commit', '-m', 'target changes hook', cwd=repo)
target_tip = self.git('rev-parse', 'HEAD', cwd=repo).stdout.strip()
self.wt_fails('git wt merge trunk --approve-hooks', cwd=source, contains='approval')
self.assertFalse(marker.exists())
self.assertEqual(target_tip, self.git('rev-parse', 'HEAD', cwd=repo).stdout.strip())
self.assertTrue(source.exists())
def test_merge_reports_partial_success_when_pre_remove_hook_fails(self):
repo, _ = self.ordinary_clone()
source = self.case / "partial source"
self.git("worktree", "add", "-b", "partial", source, cwd=repo)
self.commit(source, "partial.txt", "done\n", "partial candidate")
failer = self.case / "pre_remove_fails.py"
failer.write_text("import sys\nsys.exit(43)\n", encoding="utf-8")
self.write_project_hooks(source, {"pre-remove": [[sys.executable, str(failer)]]})
self.git("add", ".config/nu-wt.nuon", cwd=source)
self.git("commit", "-m", "configure cleanup check", cwd=source)
self.wt_fails("git wt merge trunk --message partial --approve-hooks", cwd=source, contains="partial")
self.assertEqual("done\n", (repo / "partial.txt").read_text(encoding="utf-8"))
self.assertTrue(source.exists(), "failed cleanup must not remove source")
self.assertTrue(self.branch_exists(repo, "partial"))
def test_pr_checkout_and_pr_listing_use_explicit_mocked_provider_only(self):
repo, remote = self.ordinary_clone()
tip = self.git("rev-parse", "trunk", cwd=repo).stdout.strip()
# This local bare remote models GitHub/Forgejo's required pull-head ref
# without making a network request. Checkout must explicitly fetch it.
self.git("update-ref", "refs/pull/17/head", tip, cwd=remote)
prs = self.wt_json("git wt prs --remote origin", cwd=repo)["result"]
self.assertEqual(17, prs[0]["number"])
self.assertEqual("Fixture PR", prs[0]["title"])
self.assertEqual("origin", prs[0]["remote"])
self.assertIn("provider", prs[0])
self.assertTrue(self.log.exists())
checked_out = self.wt_json("git wt switch pr:17 --remote origin", cwd=repo)
pr_path = Path(checked_out["cwd"])
self.assertNotEqual("", self.git("branch", "--show-current", cwd=pr_path).stdout.strip())
self.assertEqual(tip, self.git("rev-parse", "HEAD", cwd=pr_path).stdout.strip())
self.assertTrue((pr_path / "README.md").exists())
self.commit(pr_path, 'local-pr-work.txt', 'keep\n', 'local PR work')
local_tip = self.git('rev-parse', 'HEAD', cwd=pr_path).stdout.strip()
repeated = self.wt_json('git wt switch pr:17 --remote origin', cwd=repo)
self.assertEqual(str(pr_path.resolve()), repeated['cwd'])
self.assertEqual(local_tip, self.git('rev-parse', 'HEAD', cwd=pr_path).stdout.strip())
def test_provider_json_and_fail_closed_errors(self):
repo, _ = self.ordinary_clone()
self.git('remote', 'set-url', 'origin', 'https://github.com/fixture/project.git', cwd=repo)
result = self.wt_json('git wt prs --remote origin', cwd=repo)['result']
self.assertEqual('github', result[0]['provider'])
self.assertEqual('Fixture PR', result[0]['title'])
for mode, message in [('failure', 'authentication failure'), ('malformed', 'invalid PR JSON')]:
environment = self.environment.copy()
environment['WT_FAKE_MODE'] = mode
self.wt_fails('git wt prs --remote origin', cwd=repo, contains=message, environment=environment)
self.assertNotIn('fj ', self.log.read_text(encoding='utf-8'))
self.git('remote', 'set-url', 'origin', 'https://forgejo.example.invalid/owner/github-project.git', cwd=repo)
self.assertEqual('forgejo', self.wt_json('git wt prs --remote origin', cwd=repo)['result'][0]['provider'])
environment = self.environment.copy()
environment['WT_FAKE_MODE'] = 'malformed'
self.wt_fails('git wt prs --remote origin', cwd=repo, contains='unrecognized fj', environment=environment)
def test_completion_is_local_read_only_and_returns_valid_replacement_spans(self):
repo, _ = self.ordinary_clone()
self.git("branch", "feature/complete", cwd=repo)
text = "git wt switch feature/co"
result = self.nu(
nu_literal(text) + " | commandline complete --detailed | to json",
cwd=repo,
)
self.assertEqual(0, result.returncode, result.stderr)
records = json.loads(result.stdout)
suggestion = next(row for row in records if "feature/complete" in row["value"])
self.assertIsInstance(suggestion["span"]["start"], int)
self.assertIsInstance(suggestion["span"]["end"], int)
self.assertGreaterEqual(suggestion["span"]["start"], 0)
self.assertLessEqual(suggestion["span"]["end"], len(text))
completed = text[: suggestion["span"]["start"]] + suggestion["value"] + text[suggestion["span"]["end"] :]
self.assertIn("feature/complete", completed)
self.assertFalse(self.log.exists(), "completion must not invoke forge CLIs")
def test_empty_hook_configs_and_explicit_skip(self):
repo, _ = self.ordinary_clone()
self.config.write_text('{hooks: {}}\n', encoding='utf-8')
self.approvals.write_text('{}\n', encoding='utf-8')
created = self.wt_json('git wt switch --create empty-config --base trunk', cwd=repo)
self.assertTrue(Path(created['cwd']).is_dir())
self.config.write_text('not valid [', encoding='utf-8')
skipped = self.wt_json('git wt switch --create skip-config --base trunk --no-hooks', cwd=repo)
self.assertTrue(Path(skipped['cwd']).is_dir())
def test_completion_quotes_literal_worktree_paths(self):
repo, _ = self.ordinary_clone()
arbitrary = self.case / 'literal worktree path'
self.git('worktree', 'add', '-b', 'quoted-path', arbitrary, cwd=repo)
text = 'git wt switch `'+ str(arbitrary)[:-4]
result = self.nu(nu_literal(text) + ' | commandline complete --detailed | to json', cwd=repo)
self.assertEqual(0, result.returncode, result.stderr)
records = json.loads(result.stdout)
suggestion = next(row for row in records if 'literal worktree path' in row['value'])
span = suggestion['span']
completed = text[:span['start']] + suggestion['value'] + text[span['end']:]
switched = self.wt_json(completed, cwd=repo)
self.assertEqual(str(arbitrary.resolve()), switched['cwd'])
def test_standard_git_completion_still_delegates(self):
repo, _ = self.ordinary_clone()
help_result = self.nu('git wt switch --help', cwd=repo)
self.assertEqual(0, help_result.returncode, help_result.stderr)
self.assertIn('--execute', help_result.stdout)
result = self.nu(
'$env.config.completions.external.completer = {|place| [external-completion-ok]}; '
"'git checkout ext' | commandline complete | to json", cwd=repo,
)
self.assertEqual(0, result.returncode, result.stderr)
self.assertIn('external-completion-ok', json.loads(result.stdout))
@unittest.skipUnless(os.name == 'nt', 'Windows startup-directory handle safety')
def test_startup_directory_removal_is_refused_without_mutation(self):
repo, _ = self.ordinary_clone()
held = self.case / 'held'
self.git('worktree', 'add', '-b', 'held', held, cwd=repo)
result = subprocess.run(
[NU, '--no-config-file', '-c', f"$env.config.error_style = 'plain'; use {nu_literal(MODULE)}; git wt remove --keep-branch"],
cwd=held, env=self.environment, capture_output=True, encoding='utf-8', timeout=30,
)
self.assertNotEqual(0, result.returncode)
self.assertIn('startup cwd', result.stderr)
self.assertTrue(held.exists())
self.assertTrue(self.branch_exists(repo, 'held'))
def test_git_alias_remains_usable_with_native_namespace(self):
repo, _ = self.ordinary_clone()
result = self.nu("alias g = git; g wt list | to json", cwd=repo)
self.assertEqual(0, result.returncode, result.stderr)
rows = json.loads(result.stdout)
self.assertEqual("trunk", rows[0]["branch"])
if __name__ == "__main__":
unittest.main()