test: reproduce gitlink-with-no-.gitmodules abort (#1380)

A gitlink (mode 160000) outside `src` that has no matching .gitmodules
entry currently aborts the whole fetch, because `checkout_version` runs
`git submodule update --init --recursive` and `submodules()` before
`_apply_src_and_ignore` gets a chance to drop out-of-scope submodules.

Add a fast unit test exercising GitLocalRepo.checkout_version directly
against a real repo, and a matching behave scenario mirroring the
issue's reproduction steps. Both currently fail with the exact error
from the issue: "fatal: No url found for submodule path '...' in
.gitmodules".

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DziAso23sxMgeTSUmzkus8

Author: claude

features/fetch-git-repo-with-submodule.feature

@@ -220,6 +220,33 @@ Feature: Fetch projects with nested VCS dependencies
                             README.md
             """
 
+    Scenario: A gitlink with no .gitmodules entry outside src does not abort the fetch
+        Given a git-repository "GitlinkProject.git" with "vendored" and a stray gitlink "some/worktree" outside it
+        Given the manifest 'dfetch.yaml' in MyProject
+            """
+            manifest:
+                version: 0.0
+                projects:
+                    - name: gitlink-project
+                      url: some-remote-server/GitlinkProject.git
+                      src: vendored
+            """
+        When I run "dfetch update"
+        Then the output shows
+            """
+            Dfetch (0.14.3)
+              gitlink-project:
+              > Fetched master - e1fda19a57b873eb8e6ae37780594cbb77b70f1a
+            """
+        Then 'MyProject' looks like:
+            """
+            MyProject/
+                dfetch.yaml
+                gitlink-project/
+                    .dfetch_data.yaml
+                    file.txt
+            """
+
     Scenario: A sibling submodule at the same top-level dir as src is not fetched
         Given a git-repository "SiblingSubmoduleProject.git" with the following submodules
             | path        | url                             | revision |

features/steps/git_steps.py

@@ -69,6 +69,37 @@ def step_impl(context, name=None):
         commit_all("Added submodules")
 
 
+@given(
+    'a git-repository "{name}" with "{src_dir}" and a stray gitlink "{gitlink_path}" outside it'
+)
+def step_impl(context, name, src_dir, gitlink_path):
+    remote_path = os.path.join(context.remotes_dir, name)
+    pathlib.Path(remote_path).mkdir(parents=True, exist_ok=True)
+
+    with in_directory(remote_path):
+        create_repo()
+        generate_file(os.path.join(src_dir, "file.txt"), "hello")
+        commit_all("Initial commit")
+
+        sha = subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip()
+        # A gitlink (mode 160000) with no corresponding .gitmodules entry, e.g. as
+        # left behind by an accidentally committed `git worktree` or nested checkout.
+        # `git add -A` would see the gitlink path as missing on disk and drop it
+        # again, so commit directly instead of going through commit_all().
+        subprocess.check_call(
+            [
+                "git",
+                "update-index",
+                "--add",
+                "--cacheinfo",
+                f"160000,{sha},{gitlink_path}",
+            ]
+        )
+        subprocess.check_call(
+            ["git", "commit", "-m", "Added a stray gitlink with no .gitmodules entry"]
+        )
+
+
 @given('a new tag "{tagname}" is added to git-repository "{name}"')
 def step_impl(context, tagname, name):
     remote_path = os.path.join(context.remotes_dir, name)

tests/test_git_vcs.py

@@ -4,6 +4,7 @@
 # flake8: noqa
 
 import os
+import subprocess
 from subprocess import CompletedProcess
 from unittest.mock import Mock, patch
 
@@ -16,7 +17,7 @@
     GitRemote,
     _build_git_ssh_command,
 )
-from dfetch.vcs.git_types import Submodule
+from dfetch.vcs.git_types import CheckoutOptions, Submodule
 
 # ---------------------------------------------------------------------------
 # unique_parent_dirs  (dfetch.util.util)
@@ -219,6 +220,63 @@ def test_filter_submodules_sibling_of_src_not_removed(tmp_path, monkeypatch):
     ), "src submodule should appear in result before final os.path.exists filtering"
 
 
+# ---------------------------------------------------------------------------
+# GitLocalRepo.checkout_version — gitlink with no .gitmodules entry (#1380)
+# ---------------------------------------------------------------------------
+
+
+def _init_git_repo(path):
+    subprocess.check_call(["git", "init", "--initial-branch=main", "--quiet"], cwd=path)
+    subprocess.check_call(["git", "config", "user.email", "you@example.com"], cwd=path)
+    subprocess.check_call(["git", "config", "user.name", "John Doe"], cwd=path)
+    subprocess.check_call(["git", "config", "commit.gpgsign", "false"], cwd=path)
+
+
+def test_checkout_version_survives_gitlink_with_no_gitmodules_entry_outside_src(
+    tmp_path,
+):
+    """Reproduces #1380.
+
+    An upstream repo can contain a gitlink (mode 160000) with no matching
+    entry in .gitmodules — e.g. an accidentally committed `git worktree`.
+    `git submodule update`/`foreach` abort on such a gitlink even when it
+    sits entirely outside the requested `src`, so the whole fetch must not
+    be allowed to die because of it.
+    """
+    upstream = tmp_path / "upstream"
+    upstream.mkdir()
+    _init_git_repo(upstream)
+    (upstream / "vendored").mkdir()
+    (upstream / "vendored" / "file.txt").write_text("hello")
+    subprocess.check_call(["git", "add", "-A"], cwd=upstream)
+    subprocess.check_call(["git", "commit", "-qm", "initial"], cwd=upstream)
+
+    sha = (
+        subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=upstream)
+        .decode()
+        .strip()
+    )
+    subprocess.check_call(
+        ["git", "update-index", "--add", "--cacheinfo", f"160000,{sha},some/worktree"],
+        cwd=upstream,
+    )
+    subprocess.check_call(
+        ["git", "commit", "-qm", "commit a gitlink with no .gitmodules entry"],
+        cwd=upstream,
+    )
+
+    consumer = tmp_path / "consumer"
+    consumer.mkdir()
+    repo = GitLocalRepo(str(consumer))
+
+    _, submodules = repo.checkout_version(
+        CheckoutOptions(remote=str(upstream), version="main", src="vendored")
+    )
+
+    assert submodules == []
+    assert (consumer / "file.txt").read_text() == "hello"
+
+
 @pytest.mark.parametrize(
     "name, cmd_result, expectation",
     [