Improve submodule test: create proper gitlink and verify clone

- CreateGitServerWithSubmodule now creates a proper git submodule with:
  - .gitmodules file
  - Submodule config in .git/config
  - Gitlink entry (mode 160000) in the index pointing to submodule commit
- Add CommitSubmodule helper to create proper submodule entries
- Update TestGitSubmodules to verify the submodule file is actually cloned,
  not just that .gitmodules exists

Author: bjornrobertsson

integration/integration_test.go

@@ -422,7 +422,7 @@ func TestGitSubmodules(t *testing.T) {
 	t.Parallel()
 
 	// Create parent repo with a submodule
-	parentSrv, submoduleSrv := gittest.CreateGitServerWithSubmodule(t, gittest.Options{
+	parentSrv, _ := gittest.CreateGitServerWithSubmodule(t, gittest.Options{
 		Files: map[string]string{
 			"Dockerfile": "FROM " + testImageAlpine,
 		},
@@ -442,7 +442,10 @@ func TestGitSubmodules(t *testing.T) {
 	// Verify the .gitmodules file exists
 	gitmodules := execContainer(t, ctr, "cat /workspaces/empty/.gitmodules")
 	require.Contains(t, gitmodules, "[submodule")
-	require.Contains(t, gitmodules, submoduleSrv.URL)
+
+	// Verify the submodule was actually cloned by checking for the file inside it
+	subfileContent := execContainer(t, ctr, "cat /workspaces/empty/submod/subfile.txt")
+	require.Contains(t, subfileContent, "submodule content")
 }
 
 func TestGitSSHAuth(t *testing.T) {

testutil/gittest/gittest.go

@@ -20,8 +20,11 @@ import (
 	"github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-billy/v5/memfs"
 	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/cache"
+	"github.com/go-git/go-git/v5/plumbing/filemode"
+	"github.com/go-git/go-git/v5/plumbing/format/index"
 	"github.com/go-git/go-git/v5/plumbing/format/pktline"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/go-git/go-git/v5/plumbing/protocol/packp"
@@ -272,38 +275,107 @@ func NewRepo(t *testing.T, fs billy.Filesystem, commits ...CommitFunc) *git.Repo
 
 // CreateGitServerWithSubmodule creates a parent git repo with a submodule pointing to another repo.
 // Returns the parent server and the submodule server.
+// The submodule is properly registered with a gitlink entry in the tree.
 func CreateGitServerWithSubmodule(t *testing.T, opts Options, submoduleOpts Options) (parentSrv *httptest.Server, submoduleSrv *httptest.Server) {
 	t.Helper()
 
-	// Create the submodule repo first
-	submoduleSrv = CreateGitServer(t, submoduleOpts)
+	// Create the submodule repo first and get its HEAD commit
+	submoduleFS := memfs.New()
+	submoduleCommits := make([]CommitFunc, 0)
+	for path, content := range submoduleOpts.Files {
+		submoduleCommits = append(submoduleCommits, Commit(t, path, content, "submodule commit"))
+	}
+	submoduleRepo := NewRepo(t, submoduleFS, submoduleCommits...)
+
+	// Get the submodule's HEAD commit hash
+	submoduleHead, err := submoduleRepo.Head()
+	require.NoError(t, err)
+	submoduleHash := submoduleHead.Hash()
+
+	// Start the submodule server
+	if submoduleOpts.AuthMW == nil {
+		submoduleOpts.AuthMW = mwtest.BasicAuthMW(submoduleOpts.Username, submoduleOpts.Password)
+	}
+	if submoduleOpts.TLS {
+		submoduleSrv = httptest.NewTLSServer(submoduleOpts.AuthMW(NewServer(submoduleFS)))
+	} else {
+		submoduleSrv = httptest.NewServer(submoduleOpts.AuthMW(NewServer(submoduleFS)))
+	}
 
-	// Create the parent repo with .gitmodules pointing to submodule
+	// Create the parent repo with .gitmodules and gitlink entry
 	if opts.AuthMW == nil {
 		opts.AuthMW = mwtest.BasicAuthMW(opts.Username, opts.Password)
 	}
 
-	fs := memfs.New()
+	parentFS := memfs.New()
 	commits := make([]CommitFunc, 0)
 	for path, content := range opts.Files {
 		commits = append(commits, Commit(t, path, content, "my test commit"))
 	}
-	// Add gitmodules file pointing to the submodule server
-	gitmodulesContent := fmt.Sprintf(`[submodule "submod"]
-	path = submod
-	url = %s
-`, submoduleSrv.URL)
-	commits = append(commits, Commit(t, ".gitmodules", gitmodulesContent, "add submodule"))
-	_ = NewRepo(t, fs, commits...)
+
+	// Add .gitmodules file and gitlink entry for the submodule
+	commits = append(commits, CommitSubmodule(t, "submod", submoduleSrv.URL, submoduleHash))
+
+	_ = NewRepo(t, parentFS, commits...)
 
 	if opts.TLS {
-		parentSrv = httptest.NewTLSServer(opts.AuthMW(NewServer(fs)))
+		parentSrv = httptest.NewTLSServer(opts.AuthMW(NewServer(parentFS)))
 	} else {
-		parentSrv = httptest.NewServer(opts.AuthMW(NewServer(fs)))
+		parentSrv = httptest.NewServer(opts.AuthMW(NewServer(parentFS)))
 	}
 	return parentSrv, submoduleSrv
 }
 
+// CommitSubmodule creates a commit that adds a submodule with proper .gitmodules and gitlink entry.
+func CommitSubmodule(t *testing.T, path, url string, hash plumbing.Hash) CommitFunc {
+	return func(fs billy.Filesystem, repo *git.Repository) {
+		t.Helper()
+		tree, err := repo.Worktree()
+		require.NoError(t, err)
+
+		// Create .gitmodules file
+		gitmodulesContent := fmt.Sprintf("[submodule %q]\n\tpath = %s\n\turl = %s\n", path, path, url)
+		WriteFile(t, fs, ".gitmodules", gitmodulesContent)
+		_, err = tree.Add(".gitmodules")
+		require.NoError(t, err)
+
+		// Add submodule config to .git/config
+		cfg, err := repo.Config()
+		require.NoError(t, err)
+		cfg.Submodules[path] = &config.Submodule{
+			Name: path,
+			Path: path,
+			URL:  url,
+		}
+		err = repo.SetConfig(cfg)
+		require.NoError(t, err)
+
+		// Create the gitlink entry (mode 160000 commit reference)
+		// We need to add it directly to the index
+		idx, err := repo.Storer.Index()
+		require.NoError(t, err)
+
+		// Add a gitlink entry - this is a special index entry with mode 160000
+		idx.Entries = append(idx.Entries, &index.Entry{
+			Mode: filemode.Submodule,
+			Hash: hash,
+			Name: path,
+		})
+		err = repo.Storer.SetIndex(idx)
+		require.NoError(t, err)
+
+		// Commit the changes
+		_, err = tree.Commit("add submodule", &git.CommitOptions{
+			Author: &object.Signature{
+				Name:  "Example",
+				Email: "test@example.com",
+				When:  time.Now(),
+			},
+		})
+		require.NoError(t, err)
+	}
+}
+
 // WriteFile writes a file to the filesystem.
 func WriteFile(t *testing.T, fs billy.Filesystem, path, content string) {
 	t.Helper()