"""REAL tests for the stdlib smart-HTTP git server: serve a temp repo, clone

it with the actual git CLI, push a commit back, and observe protocol v2

passing through. This is the piece of the netshape slice the macOS dev host

can exercise for real."""

from __future__ import annotations

import os

import shutil

import subprocess

import sys

import tempfile

import unittest

from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))

from oakbench.environment import base_env

from oakbench.gitserver import GitHTTPServer

GIT = shutil.which("git")

def run_git(args: list[str], cwd: Path | None = None) -> subprocess.CompletedProcess:

    return subprocess.run(

        [GIT, *args],

        cwd=cwd,

        env=base_env(),

        stdout=subprocess.PIPE,

        stderr=subprocess.PIPE,

        text=True,

        timeout=120,

        check=False,

    )

@unittest.skipIf(GIT is None, "git binary not installed")

class GitHTTPServerTest(unittest.TestCase):

    def setUp(self) -> None:

        self.tmp = Path(tempfile.mkdtemp(prefix="oak-gitserver-test-"))

        self.addCleanup(shutil.rmtree, self.tmp, True)

        src = self.tmp / "src"

        run_git(["-c", "init.defaultBranch=main", "init", str(src)])

        (src / "README.md").write_text("# gitserver fixture\n")

        run_git(["add", "-A"], cwd=src)

        commit = run_git(["commit", "-m", "fixture commit"], cwd=src)

        self.assertEqual(commit.returncode, 0, commit.stderr)

        self.served_root = self.tmp / "served"

        self.served_root.mkdir()

        self.bare = self.served_root / "repo.git"

        run_git(["clone", "--bare", str(src), str(self.bare)])

        # Push over http works only when the served repo opts in.

        run_git(["-C", str(self.bare), "config", "http.receivepack", "true"])

        self.server = GitHTTPServer(self.served_root).start()

        self.addCleanup(self.server.stop)

        self.repo_url = f"{self.server.url}/repo.git"

    def test_clone_succeeds_and_logs_smart_paths(self) -> None:

        dest = self.tmp / "clone"

        result = run_git(["clone", self.repo_url, str(dest)])

        self.assertEqual(result.returncode, 0, result.stderr)

        self.assertEqual((dest / "README.md").read_text(), "# gitserver fixture\n")

        self.assertTrue(

            any(

                "/repo.git/info/refs" in entry and "service=git-upload-pack" in entry

                for entry in self.server.request_log

            ),

            self.server.request_log,

        )

    def test_push_over_http_succeeds(self) -> None:

        dest = self.tmp / "pusher"

        clone = run_git(["clone", self.repo_url, str(dest)])

        self.assertEqual(clone.returncode, 0, clone.stderr)

        (dest / "delta.txt").write_text("pushed over http\n")

        run_git(["add", "-A"], cwd=dest)

        commit = run_git(["commit", "-m", "small delta"], cwd=dest)

        self.assertEqual(commit.returncode, 0, commit.stderr)

        local_head = run_git(["rev-parse", "HEAD"], cwd=dest).stdout.strip()

        push = run_git(["push", "origin", "main"], cwd=dest)

        self.assertEqual(push.returncode, 0, push.stderr)

        served_head = run_git(["-C", str(self.bare), "rev-parse", "main"]).stdout.strip()

        self.assertEqual(served_head, local_head)

        self.assertTrue(

            any("git-receive-pack" in entry for entry in self.server.request_log),

            self.server.request_log,

        )

    def test_push_refused_without_receivepack_optin(self) -> None:

        run_git(["-C", str(self.bare), "config", "--unset", "http.receivepack"])

        dest = self.tmp / "refused"

        clone = run_git(["clone", self.repo_url, str(dest)])

        self.assertEqual(clone.returncode, 0, clone.stderr)

        (dest / "delta.txt").write_text("should be refused\n")

        run_git(["add", "-A"], cwd=dest)

        run_git(["commit", "-m", "refused delta"], cwd=dest)

        push = run_git(["push", "origin", "main"], cwd=dest)

        self.assertNotEqual(push.returncode, 0)

    def test_protocol_v2_header_passes_through(self) -> None:

        dest = self.tmp / "clone-v2"

        result = run_git(["-c", "protocol.version=2", "clone", self.repo_url, str(dest)])

        self.assertEqual(result.returncode, 0, result.stderr)

        self.assertTrue(

            any("version=2" in value for value in self.server.git_protocol_headers),

            self.server.git_protocol_headers,

        )

    def test_url_requires_started_server(self) -> None:

        stopped = GitHTTPServer(self.served_root)

        with self.assertRaises(RuntimeError):

            _ = stopped.url

    def test_missing_repo_is_a_client_error_not_a_crash(self) -> None:

        dest = self.tmp / "missing"

        result = run_git(["clone", f"{self.server.url}/nope.git", str(dest)])

        self.assertNotEqual(result.returncode, 0)

        # Server is still healthy afterwards.

        ok = run_git(["clone", self.repo_url, str(self.tmp / "still-works")])

        self.assertEqual(ok.returncode, 0, ok.stderr)

if __name__ == "__main__":

    unittest.main()