perf(tests): reduce Windows submodule process overhead

Windows process startup makes repeated Git version probes and missing-hook
checks costly in the submodule tests. A relative `git` executable also
prevents the existing minimum-version cache from being shared on Windows.

Resolve `git.exe` from `PATH` to an absolute `GIT_PYTHON_GIT_EXECUTABLE` for
Windows CI and the local runner, preserving explicit overrides. Use the
selected executable for the runner's direct Git commands. Pass
`skip_hooks=True` at 70 submodule fixture commit sites, preserving normal
`IndexFile.commit()` defaults and dedicated hook coverage.

Match CI's private configuration by appending the alias fixture directly
and retaining `core.autocrlf=true` on Windows. The previous `include.path`
forced Gix repository reloads during local measurements. Document the Git
Bash invocation and distinguish these local setup corrections from CI gains.

Validation also exposed a daemon-test deadline shorter than Windows' closed
loopback-port refusal delay: fresh closed ports returned `TimeoutError` at
two seconds and `ConnectionRefusedError` just after 2.02 seconds. Allow five
seconds for the post-shutdown check while retaining its strict refusal
assertion and restart coverage.

A controlled, serial 37-case Windows Gix sample with identical flat config,
profiling enabled and coverage disabled improved from 87.10s to 77.20s.
Git launches fell from 1,437 to 1,128: 132 fewer version probes and 177 fewer
hook checks. This is about 11% faster in the sample, not a full-suite estimate.

Validation used CPython 3.12.13, Git 2.55.0.windows.5 and `GixPython` 0.1.0:

- Both complete submodule modules and related checks ran with CI's coverage
  options. CLI finished with 542 passed, 1 skipped, 1 xfailed and 3 xpassed.
- The initial Gix selection had 546 passed, 1 failed, 1 xfailed and 3 xpassed.
  Its sole failure was the daemon deadline corrected here; that regression
  passed on a targeted rerun and in the subsequent CLI run.
- Replaying the original submodule source from `c3a2832b` reproduced the CLI
  `test_base_rw` file-lock skip, confirming it predates these changes.
- Pre-commit checks passed for all changed files. Git Bash checks covered
  executable resolution, explicit overrides and the non-Windows branch;
  changed Python files also parse with Python 3.8 syntax.

The macOS Python 3.9 through 3.13 CI jobs failed before pytest with
`conditional binary operator expected`: Apple's Bash 3.2 parses the complete
Windows setup condition and does not support `[[ -v VARIABLE ]]`, even when
the operating-system comparison is false. Use `${VARIABLE+x}` to test whether
`GIT_PYTHON_GIT_EXECUTABLE` is set, preserving explicitly empty values and
leaving Windows discovery limited to an unset executable override.

Validation: the six OS/unset/empty/value combinations passed under Apple's
Bash 3.2.57; the workflow's applicable pre-commit checks and `git diff --check`
passed. Hosted macOS validation follows the push.

Windows CI subsequently exposed a historical command-mock assumption in
`test_call_process_calls_execute`: after this workflow pins the executable,
`Git.version()` correctly passes its absolute path instead of the literal
`git`. Assert against `Git.GIT_PYTHON_GIT_EXECUTABLE` so the test retains its
command-dispatch happy path with either executable configuration. The
focused test passed with `GIT_PYTHON_GIT_EXECUTABLE=/usr/bin/git`.

Author: Byron

.github/workflows/pythonpackage.yml

@@ -223,6 +223,11 @@ jobs:
 
     - name: Test with pytest
       run: |
+        if [[ "$RUNNER_OS" == "Windows" && -z "${GIT_PYTHON_GIT_EXECUTABLE+x}" ]]; then
+          # Absolute paths let Windows share minimum-version probes.
+          git_executable="$(python -c 'import os, shutil; print(os.path.abspath(shutil.which("git")))')"
+          export GIT_PYTHON_GIT_EXECUTABLE="$git_executable"
+        fi
         pytest --color=yes -p no:sugar --instafail -vv --durations=30 \
           --junitxml=test-results/pytest.xml --backend-report=test-results/backend.json
       continue-on-error: false

doc/gix-backend.md

@@ -53,6 +53,24 @@ The prepared environments in this checkout are `.venv` (CLI) and `.tox/gix`
     --backend-report=.cache/gix-coverage.json
 ```
 
+On Windows, use Git Bash, as CI does, and the environments' `Scripts`
+directories. To retain CI's coverage and pytest options:
+
+```sh
+.venv/Scripts/python.exe test/run-local.py --color=yes -p no:sugar --instafail -vv --durations=30 \
+    --junitxml=.cache/windows-cli.xml --backend-report=.cache/windows-cli.json
+.tox/gix/Scripts/python.exe test/run-local.py --color=yes -p no:sugar --instafail -vv --durations=30 \
+    --junitxml=.cache/windows-gix.xml --backend-report=.cache/windows-gix.json
+```
+
+The Windows runner resolves `git.exe` from `PATH` to an absolute path so
+GitPython can share minimum-version checks. An explicit
+`GIT_PYTHON_GIT_EXECUTABLE` override is preserved and also used for the runner's
+direct Git commands. Git Bash normally selects `mingw64/bin/git.exe`; the
+`cmd/git.exe` and `bin/git.exe` launchers add overhead to local measurements.
+The private config retains CI's `core.autocrlf=true` on Windows and appends
+the test aliases directly, matching CI without introducing config includes.
+
 The runner uses local version tags, creates an isolated Git configuration,
 prepares the historical test fixture inside a temporary shared clone, gives
 pytest a separate temporary root for each run, and disables package-index
@@ -518,6 +536,35 @@ repository-open benchmark above measures the affected operation separately.
 Logs, profiles, JUnit results and backend reports are retained locally under
 `.cache/ci-performance/`.
 
+### Submodule fixture process overhead on Windows
+
+Windows CI and the local runner now resolve `git.exe` from `PATH` to an
+absolute `GIT_PYTHON_GIT_EXECUTABLE` when no override was supplied. This enables
+the existing minimum-version cache without changing the library's executable
+lookup or cache invalidation. Submodule fixtures also pass `skip_hooks=True`
+when committing their test history; the library default and dedicated hook
+tests continue to run hooks.
+
+A serial Windows comparison on CPython 3.12.13, Git 2.55.0.windows.5 and
+GixPython 0.1.0 selected the Windows destination-name rejection tests,
+`test_update_no_fetch_restores_deinitialized_submodule`, and
+`test_update_no_fetch_is_recursive`. Both runs used the direct Git executable
+on `PATH`, CI's flat alias config and `core.autocrlf=true`, with profiling
+enabled and coverage disabled. All 37 cases passed in both runs.
+
+| Test invocation and fixtures | Pytest time | Git launches | Version probes | Hook launches |
+| --- | ---: | ---: | ---: | ---: |
+| `GIT_PYTHON_GIT_EXECUTABLE=git`, fixture hooks enabled | 87.10s | 1,437 | 403 | 177 |
+| Absolute executable, fixture hooks skipped | 77.20s | 1,128 | 271 | 0 |
+
+The 309 eliminated launches comprise 132 redundant version probes and three
+hook checks for each of 59 fixture commits. This sample was about 11% faster;
+it is not a full-suite speedup estimate. Git Bash CI already selects
+`mingw64/bin/git.exe` and appends the alias config directly, so correcting the
+local runner's launcher/config differences is not an additional CI gain.
+Logs, profiles, JUnit results and operation reports are retained locally under
+`.cache/test-cleanup/windows-submodule-{baseline,optimized}*`.
+
 ### Test-suite setup measurements
 
 The fixture optimizations below are implemented as separate commits, each

test/run-local.py

@@ -6,6 +6,7 @@
 
 import os
 from pathlib import Path
+import shutil
 import socket
 import subprocess
 import sys
@@ -18,7 +19,14 @@ def main():
     with TemporaryDirectory(prefix="gitpython-local-tests-") as directory:
         temporary = Path(directory)
         config = temporary / "gitconfig"
-        config.write_text("[user]\nname = GitPython Tests\nemail = tests@example.invalid\n", encoding="utf-8")
+        text = "[user]\nname = GitPython Tests\nemail = tests@example.invalid\n"
+        if sys.platform == "win32":
+            # Match CI's Git for Windows setting despite disabling system config.
+            text += "[core]\nautocrlf = true\n"
+        # CI appends these aliases directly. An include forces Gix to reload its
+        # configuration before every operation because included files can change.
+        text += (root / "test/fixtures/.gitconfig").read_text(encoding="utf-8")
+        config.write_text(text, encoding="utf-8")
         env = {
             **os.environ,
             "GIT_CONFIG_NOSYSTEM": "1",
@@ -28,11 +36,17 @@ def main():
             "PIP_FIND_LINKS": os.environ.get("PIP_FIND_LINKS", str(root / ".cache/gix-wheels")),
             "UV_OFFLINE": "1",
         }
+        if sys.platform == "win32" and "GIT_PYTHON_GIT_EXECUTABLE" not in env:
+            executable = shutil.which("git")
+            if executable is None:
+                raise RuntimeError("Git executable not found in PATH")
+            # Windows can share minimum-version checks for an absolute path.
+            env["GIT_PYTHON_GIT_EXECUTABLE"] = os.path.abspath(executable)
+        git_executable = env.get("GIT_PYTHON_GIT_EXECUTABLE", "git")
 
         def git(*args, cwd=root):
-            return subprocess.check_output(["git", *map(str, args)], cwd=cwd, env=env, text=True).strip()
+            return subprocess.check_output([git_executable, *map(str, args)], cwd=cwd, env=env, text=True).strip()
 
-        git("config", "--file", config, "include.path", root / "test/fixtures/.gitconfig")
         fixture = temporary / "repo"
         git("clone", "--shared", "--no-checkout", root, fixture)
         git("checkout", "--detach", git("rev-parse", "HEAD"), cwd=fixture)

test/test_cleanup.py

@@ -198,8 +198,9 @@ def test_git_daemon_releases_port_and_can_restart(tmp_path):
                 with suppress(ConnectionResetError):  # Git for Windows resets rejected requests.
                     assert connection.recv(1) == b""
 
+        # Windows can take just over two seconds to refuse a closed loopback port.
         with pytest.raises(ConnectionRefusedError):
-            with socket.create_connection(address, timeout=2):
+            with socket.create_connection(address, timeout=5):
                 pass
 
 

test/test_git.py

@@ -118,7 +118,7 @@ def test_call_process_calls_execute(self, git):
         git.return_value = ""
         self.git.version()
         self.assertTrue(git.called)
-        self.assertEqual(git.call_args, ((["git", "version"],), {}))
+        self.assertEqual(git.call_args, (([Git.GIT_PYTHON_GIT_EXECUTABLE, "version"],), {}))
 
     def test_call_unpack_args_unicode(self):
         args = Git._unpack_args("Unicode€™")