Fix Git Flow

tests/test_git_tui.py

@@ -2,9 +2,13 @@
 
 import importlib.machinery
 import importlib.util
+import os
 import pathlib
+import subprocess
 import sys
+import tempfile
 import unittest
+from unittest import mock
 
 
 SCRIPT_PATH = pathlib.Path(__file__).parents[1] / "git-tui"
@@ -62,5 +66,163 @@ class GiteaRemoteUrlTests(unittest.TestCase):
         self.assertEqual(remote_url, "")
 
 
+class RepositorySyncTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.app = git_tui.GitTuiApp.__new__(git_tui.GitTuiApp)
+        self.app.status_message = ""
+        self.app.show_output = lambda *_args: None
+        self.app.show_command_result = lambda *_args: None
+        self.original_cwd = pathlib.Path.cwd()
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.root = pathlib.Path(self.temp_dir.name)
+
+    def tearDown(self) -> None:
+        os.chdir(self.original_cwd)
+        self.temp_dir.cleanup()
+
+    def git(self, cwd: pathlib.Path, *args: str) -> str:
+        completed = subprocess.run(
+            ["git", *args],
+            cwd=cwd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        return completed.stdout.strip()
+
+    def init_worktree(self, path: pathlib.Path) -> None:
+        path.mkdir()
+        self.git(path, "init", "-b", "main")
+        self.git(path, "config", "user.name", "Test User")
+        self.git(path, "config", "user.email", "test@example.com")
+        self.git(path, "config", "commit.gpgsign", "false")
+
+    def test_sync_pushes_local_commit_to_empty_remote(self) -> None:
+        remote = self.root / "remote.git"
+        local = self.root / "local"
+        remote.mkdir()
+        self.git(remote, "init", "--bare")
+        self.init_worktree(local)
+        (local / "local.txt").write_text("local\n", encoding="utf-8")
+        self.git(local, "add", "local.txt")
+        self.git(local, "commit", "-m", "local")
+        self.git(local, "remote", "add", "origin", str(remote))
+
+        os.chdir(local)
+        self.assertTrue(self.app.sync_origin_repository())
+        self.assertEqual(
+            self.git(remote, "rev-parse", "refs/heads/main"),
+            self.git(local, "rev-parse", "HEAD"),
+        )
+
+    def test_sync_populates_unborn_local_repository_from_remote(self) -> None:
+        remote = self.root / "remote.git"
+        seed = self.root / "seed"
+        local = self.root / "local"
+        remote.mkdir()
+        self.git(remote, "init", "--bare")
+        self.git(remote, "symbolic-ref", "HEAD", "refs/heads/main")
+        self.init_worktree(seed)
+        (seed / "remote.txt").write_text("remote\n", encoding="utf-8")
+        self.git(seed, "add", "remote.txt")
+        self.git(seed, "commit", "-m", "remote")
+        self.git(seed, "remote", "add", "origin", str(remote))
+        self.git(seed, "push", "origin", "main")
+        self.init_worktree(local)
+        self.git(local, "remote", "add", "origin", str(remote))
+
+        os.chdir(local)
+        self.assertTrue(self.app.sync_origin_repository())
+        self.assertEqual((local / "remote.txt").read_text(), "remote\n")
+        self.assertEqual(
+            self.git(local, "rev-parse", "HEAD"),
+            self.git(remote, "rev-parse", "refs/heads/main"),
+        )
+
+    def test_sync_merges_diverged_histories_and_pushes_result(self) -> None:
+        remote = self.root / "remote.git"
+        seed = self.root / "seed"
+        local = self.root / "local"
+        remote.mkdir()
+        self.git(remote, "init", "--bare")
+        self.git(remote, "symbolic-ref", "HEAD", "refs/heads/main")
+        self.init_worktree(seed)
+        (seed / "remote.txt").write_text("remote\n", encoding="utf-8")
+        self.git(seed, "add", "remote.txt")
+        self.git(seed, "commit", "-m", "remote")
+        self.git(seed, "remote", "add", "origin", str(remote))
+        self.git(seed, "push", "origin", "main")
+        self.init_worktree(local)
+        (local / "local.txt").write_text("local\n", encoding="utf-8")
+        self.git(local, "add", "local.txt")
+        self.git(local, "commit", "-m", "local")
+        self.git(local, "remote", "add", "origin", str(remote))
+        self.app.select_option_menu = lambda *_args: "merge"
+
+        os.chdir(local)
+        self.assertTrue(self.app.sync_origin_repository())
+        self.assertTrue((local / "local.txt").exists())
+        self.assertTrue((local / "remote.txt").exists())
+        self.assertEqual(
+            self.git(local, "rev-parse", "HEAD"),
+            self.git(remote, "rev-parse", "refs/heads/main"),
+        )
+
+
+class GiteaPublishTests(unittest.TestCase):
+    def test_created_repository_can_keep_ssh_origin(self) -> None:
+        app = git_tui.GitTuiApp.__new__(git_tui.GitTuiApp)
+        app.status_message = ""
+        prompt_values = iter(["owner/project", "https://git.example.com"])
+        app.prompt_input = lambda *_args: next(prompt_values)
+        app.select_gitea_transport = lambda: "ssh"
+        app.select_repository_visibility = lambda: False
+        app.create_gitea_repository = lambda **_kwargs: (
+            True,
+            {
+                "clone_url": "https://git.example.com/owner/project.git",
+                "ssh_url": "git@git.example.com:owner/project.git",
+                "full_name": "owner/project",
+            },
+            "",
+        )
+        configured_urls = []
+        app.configure_origin_remote = lambda url: configured_urls.append(url) or True
+        app.push_head_to_remote_branch = lambda *_args, **_kwargs: True
+        app.current_local_branch = lambda: "main"
+        app.show_output = lambda *_args: None
+
+        with mock.patch.dict(os.environ, {"GITEA_TOKEN": "token"}, clear=False):
+            self.assertTrue(app.publish_gitea_repository())
+
+        self.assertEqual(
+            configured_urls,
+            ["git@git.example.com:owner/project.git"],
+        )
+
+
+class MainMenuTests(unittest.TestCase):
+    def test_remote_operations_and_disconnect_require_a_remote(self) -> None:
+        app = git_tui.GitTuiApp.__new__(git_tui.GitTuiApp)
+        app.has_any_remote = lambda: False
+
+        action_names = [action for _, action in app.main_menu_items()]
+
+        self.assertNotIn("push", action_names)
+        self.assertNotIn("pull", action_names)
+        self.assertNotIn("fetch", action_names)
+        self.assertNotIn("disconnect_remote", action_names)
+
+    def test_disconnect_is_available_when_a_remote_exists(self) -> None:
+        app = git_tui.GitTuiApp.__new__(git_tui.GitTuiApp)
+        app.has_any_remote = lambda: True
+
+        action_names = [action for _, action in app.main_menu_items()]
+
+        self.assertIn("push", action_names)
+        self.assertIn("pull", action_names)
+        self.assertIn("fetch", action_names)
+        self.assertIn("disconnect_remote", action_names)
+
 if __name__ == "__main__":
     unittest.main()