localrepo: Refactor `setupRepo()`-based tests no manually seed repo

The `setupRepo()` helper function used in the localrepo tests is using a
seeded repository. Refactor these tests to instead use an empty repo and
create the test data at runtime so that we can more readily support
SHA256 in those tests.

3 files changed, 244 insertions, 219 deletions

diff --git a/internal/git/localrepo/objects_test.go b/internal/git/localrepo/objects_test.go
index c5c5b1245..6b3b49dc5 100644
--- a/internal/git/localrepo/objects_test.go
+++ b/internal/git/localrepo/objects_test.go
@@ -18,7 +18,6 @@ import (
 	"gitlab.com/gitlab-org/gitaly/v15/internal/helper/text"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/testhelper"
 	"gitlab.com/gitlab-org/gitaly/v15/proto/go/gitalypb"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 type ReaderFunc func([]byte) (int, error)
@@ -28,7 +27,7 @@ func (fn ReaderFunc) Read(b []byte) (int, error) { return fn(b) }
 func TestRepo_WriteBlob(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, repoPath := setupRepo(t, withEmptyRepo())
+	_, repo, repoPath := setupRepo(t)
 
 	for _, tc := range []struct {
 		desc       string
@@ -157,6 +156,8 @@ func TestRepo_WriteTag(t *testing.T) {
 
 	cfg, repo, repoPath := setupRepo(t)
 
+	commitID := gittest.WriteCommit(t, cfg, repoPath)
+
 	for _, tc := range []struct {
 		desc        string
 		objectID    git.ObjectID
@@ -171,7 +172,7 @@ func TestRepo_WriteTag(t *testing.T) {
 		// internal/gitaly/service/operations/tags_test.go
 		{
 			desc:       "basic signature",
-			objectID:   "c7fbe50c7c7419d9701eebe64b1fdacc3df5b9dd",
+			objectID:   commitID,
 			objectType: "commit",
 			tagName:    []byte("my-tag"),
 			tagBody:    []byte(""),
@@ -182,7 +183,7 @@ func TestRepo_WriteTag(t *testing.T) {
 		},
 		{
 			desc:       "signature with time",
-			objectID:   "c7fbe50c7c7419d9701eebe64b1fdacc3df5b9dd",
+			objectID:   commitID,
 			objectType: "commit",
 			tagName:    []byte("tag-with-timestamp"),
 			tagBody:    []byte(""),
@@ -191,15 +192,15 @@ func TestRepo_WriteTag(t *testing.T) {
 				Email: []byte("root@localhost"),
 			},
 			authorDate: time.Unix(12345, 0).UTC(),
-			expectedTag: `object c7fbe50c7c7419d9701eebe64b1fdacc3df5b9dd
+			expectedTag: fmt.Sprintf(`object %s
 type commit
 tag tag-with-timestamp
 tagger root <root@localhost> 12345 +0000
-`,
+`, commitID),
 		},
 		{
 			desc:       "signature with time and timezone",
-			objectID:   "c7fbe50c7c7419d9701eebe64b1fdacc3df5b9dd",
+			objectID:   commitID,
 			objectType: "commit",
 			tagName:    []byte("tag-with-timezone"),
 			tagBody:    []byte(""),
@@ -208,11 +209,11 @@ tagger root <root@localhost> 12345 +0000
 				Email: []byte("root@localhost"),
 			},
 			authorDate: time.Unix(12345, 0).In(time.FixedZone("myzone", -60*60)),
-			expectedTag: `object c7fbe50c7c7419d9701eebe64b1fdacc3df5b9dd
+			expectedTag: fmt.Sprintf(`object %s
 type commit
 tag tag-with-timezone
 tagger root <root@localhost> 12345 -0100
-`,
+`, commitID),
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
@@ -233,7 +234,8 @@ tagger root <root@localhost> 12345 -0100
 func TestRepo_ReadObject(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+	blobID := gittest.WriteBlob(t, cfg, repoPath, []byte("content"))
 
 	for _, tc := range []struct {
 		desc    string
@@ -247,10 +249,9 @@ func TestRepo_ReadObject(t *testing.T) {
 			error: InvalidObjectError(git.ObjectHashSHA1.ZeroOID.String()),
 		},
 		{
-			desc: "valid object",
-			// README in gitlab-test
-			oid:     "3742e48c1108ced3bf45ac633b34b65ac3f2af04",
-			content: "Sample repo for testing gitlab features\n",
+			desc:    "valid object",
+			oid:     blobID,
+			content: "content",
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
@@ -264,7 +265,42 @@ func TestRepo_ReadObject(t *testing.T) {
 func TestRepo_ReadCommit(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+
+	firstParentID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("first parent"))
+	secondParentID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithMessage("second parent"))
+
+	treeID := gittest.WriteTree(t, cfg, repoPath, []gittest.TreeEntry{
+		{Path: "file", Mode: "100644", Content: "content"},
+	})
+	commitWithoutTrailers := gittest.WriteCommit(t, cfg, repoPath,
+		gittest.WithParents(firstParentID, secondParentID),
+		gittest.WithTree(treeID),
+		gittest.WithMessage("subject\n\nbody\n"),
+		gittest.WithBranch("main"),
+	)
+	commitWithTrailers := gittest.WriteCommit(t, cfg, repoPath,
+		gittest.WithParents(commitWithoutTrailers),
+		gittest.WithTree(treeID),
+		gittest.WithMessage("with trailers\n\ntrailers\n\nSigned-off-by: John Doe <john.doe@example.com>"),
+	)
+
+	// We can't use git-commit-tree(1) directly, but have to manually write signed commits.
+	signedCommit := text.ChompBytes(gittest.ExecOpts(t, cfg, gittest.ExecConfig{
+		Stdin: strings.NewReader(fmt.Sprintf(
+			`tree %s
+parent %s
+author %[3]s
+committer %[3]s
+gpgsig -----BEGIN PGP SIGNATURE-----
+some faked pgp-signature
+ -----END PGP SIGNATURE-----
+
+signed commit subject
+
+signed commit body
+`, treeID, firstParentID, gittest.DefaultCommitterSignature)),
+	}, "-C", repoPath, "hash-object", "-t", "commit", "-w", "--stdin"))
 
 	for _, tc := range []struct {
 		desc           string
@@ -286,107 +322,81 @@ func TestRepo_ReadCommit(t *testing.T) {
 		},
 		{
 			desc:     "valid commit",
-			revision: "refs/heads/master",
+			revision: "refs/heads/main",
 			expectedCommit: &gitalypb.GitCommit{
-				Id:     "1e292f8fedd741b75372e19097c76d327140c312",
-				TreeId: "07f8147e8e73aab6c935c296e8cdc5194dee729b",
+				Id:     commitWithoutTrailers.String(),
+				TreeId: treeID.String(),
 				ParentIds: []string{
-					"7975be0116940bf2ad4321f79d02a55c5f7779aa",
-					"c1c67abbaf91f624347bb3ae96eabe3a1b742478",
-				},
-				Subject:  []byte("Merge branch 'cherry-pick-ce369011' into 'master'"),
-				Body:     []byte("Merge branch 'cherry-pick-ce369011' into 'master'\n\nAdd file with a _flattable_ path\n\nSee merge request gitlab-org/gitlab-test!35"),
-				BodySize: 128,
-				Author: &gitalypb.CommitAuthor{
-					Name:  []byte("Drew Blessing"),
-					Email: []byte("drew@blessing.io"),
-					Date: &timestamppb.Timestamp{
-						Seconds: 1540830087,
-					},
-					Timezone: []byte("+0000"),
-				},
-				Committer: &gitalypb.CommitAuthor{
-					Name:  []byte("Drew Blessing"),
-					Email: []byte("drew@blessing.io"),
-					Date: &timestamppb.Timestamp{
-						Seconds: 1540830087,
-					},
-					Timezone: []byte("+0000"),
+					firstParentID.String(),
+					secondParentID.String(),
 				},
+				Subject:   []byte("subject"),
+				Body:      []byte("subject\n\nbody\n"),
+				BodySize:  14,
+				Author:    gittest.DefaultCommitAuthor,
+				Committer: gittest.DefaultCommitAuthor,
 			},
 		},
 		{
 			desc:     "trailers do not get parsed without WithTrailers()",
-			revision: "5937ac0a7beb003549fc5fd26fc247adbce4a52e",
+			revision: commitWithTrailers.Revision(),
 			expectedCommit: &gitalypb.GitCommit{
-				Id:     "5937ac0a7beb003549fc5fd26fc247adbce4a52e",
-				TreeId: "a6973545d42361b28bfba5ced3b75dba5848b955",
+				Id:     commitWithTrailers.String(),
+				TreeId: treeID.String(),
 				ParentIds: []string{
-					"570e7b2abdd848b95f2f578043fc23bd6f6fd24d",
-				},
-				Subject:  []byte("Add submodule from gitlab.com"),
-				Body:     []byte("Add submodule from gitlab.com\n\nSigned-off-by: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>\n"),
-				BodySize: 98,
-				Author: &gitalypb.CommitAuthor{
-					Name:  []byte("Dmitriy Zaporozhets"),
-					Email: []byte("dmitriy.zaporozhets@gmail.com"),
-					Date: &timestamppb.Timestamp{
-						Seconds: 1393491698,
-					},
-					Timezone: []byte("+0200"),
-				},
-				Committer: &gitalypb.CommitAuthor{
-					Name:  []byte("Dmitriy Zaporozhets"),
-					Email: []byte("dmitriy.zaporozhets@gmail.com"),
-					Date: &timestamppb.Timestamp{
-						Seconds: 1393491698,
-					},
-					Timezone: []byte("+0200"),
+					commitWithoutTrailers.String(),
 				},
-				SignatureType: gitalypb.SignatureType_PGP,
+				Subject:   []byte("with trailers"),
+				Body:      []byte("with trailers\n\ntrailers\n\nSigned-off-by: John Doe <john.doe@example.com>"),
+				BodySize:  71,
+				Author:    gittest.DefaultCommitAuthor,
+				Committer: gittest.DefaultCommitAuthor,
 			},
 		},
 		{
 			desc:     "trailers get parsed with WithTrailers()",
-			revision: "5937ac0a7beb003549fc5fd26fc247adbce4a52e",
+			revision: commitWithTrailers.Revision(),
 			opts:     []ReadCommitOpt{WithTrailers()},
 			expectedCommit: &gitalypb.GitCommit{
-				Id:     "5937ac0a7beb003549fc5fd26fc247adbce4a52e",
-				TreeId: "a6973545d42361b28bfba5ced3b75dba5848b955",
+				Id:     commitWithTrailers.String(),
+				TreeId: treeID.String(),
 				ParentIds: []string{
-					"570e7b2abdd848b95f2f578043fc23bd6f6fd24d",
-				},
-				Subject:  []byte("Add submodule from gitlab.com"),
-				Body:     []byte("Add submodule from gitlab.com\n\nSigned-off-by: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>\n"),
-				BodySize: 98,
-				Author: &gitalypb.CommitAuthor{
-					Name:  []byte("Dmitriy Zaporozhets"),
-					Email: []byte("dmitriy.zaporozhets@gmail.com"),
-					Date: &timestamppb.Timestamp{
-						Seconds: 1393491698,
-					},
-					Timezone: []byte("+0200"),
-				},
-				Committer: &gitalypb.CommitAuthor{
-					Name:  []byte("Dmitriy Zaporozhets"),
-					Email: []byte("dmitriy.zaporozhets@gmail.com"),
-					Date: &timestamppb.Timestamp{
-						Seconds: 1393491698,
-					},
-					Timezone: []byte("+0200"),
+					commitWithoutTrailers.String(),
 				},
-				SignatureType: gitalypb.SignatureType_PGP,
+				Subject:   []byte("with trailers"),
+				Body:      []byte("with trailers\n\ntrailers\n\nSigned-off-by: John Doe <john.doe@example.com>"),
+				BodySize:  71,
+				Author:    gittest.DefaultCommitAuthor,
+				Committer: gittest.DefaultCommitAuthor,
 				Trailers: []*gitalypb.CommitTrailer{
 					{
 						Key:   []byte("Signed-off-by"),
-						Value: []byte("Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>"),
+						Value: []byte("John Doe <john.doe@example.com>"),
 					},
 				},
 			},
 		},
 		{
+			desc:     "with PGP signature",
+			revision: git.Revision(signedCommit),
+			opts:     []ReadCommitOpt{},
+			expectedCommit: &gitalypb.GitCommit{
+				Id:     signedCommit,
+				TreeId: treeID.String(),
+				ParentIds: []string{
+					firstParentID.String(),
+				},
+				Subject:       []byte("signed commit subject"),
+				Body:          []byte("signed commit subject\n\nsigned commit body\n"),
+				BodySize:      42,
+				Author:        gittest.DefaultCommitAuthor,
+				Committer:     gittest.DefaultCommitAuthor,
+				SignatureType: gitalypb.SignatureType_PGP,
+			},
+		},
+		{
 			desc:        "not a commit",
-			revision:    "refs/heads/master^{tree}",
+			revision:    "refs/heads/main^{tree}",
 			expectedErr: ErrObjectNotFound,
 		},
 	} {
@@ -401,7 +411,10 @@ func TestRepo_ReadCommit(t *testing.T) {
 func TestRepo_IsAncestor(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+
+	parentCommitID := gittest.WriteCommit(t, cfg, repoPath)
+	childCommitID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithParents(parentCommitID))
 
 	for _, tc := range []struct {
 		desc         string
@@ -412,27 +425,27 @@ func TestRepo_IsAncestor(t *testing.T) {
 	}{
 		{
 			desc:       "parent is ancestor",
-			parent:     "HEAD~1",
-			child:      "HEAD",
+			parent:     parentCommitID.Revision(),
+			child:      childCommitID.Revision(),
 			isAncestor: true,
 		},
 		{
 			desc:       "parent is not ancestor",
-			parent:     "HEAD",
-			child:      "HEAD~1",
+			parent:     childCommitID.Revision(),
+			child:      parentCommitID.Revision(),
 			isAncestor: false,
 		},
 		{
 			desc:   "parent is not valid commit",
 			parent: git.ObjectHashSHA1.ZeroOID.Revision(),
-			child:  "HEAD",
+			child:  childCommitID.Revision(),
 			errorMatcher: func(t testing.TB, err error) {
 				require.Equal(t, InvalidCommitError(git.ObjectHashSHA1.ZeroOID), err)
 			},
 		},
 		{
 			desc:   "child is not valid commit",
-			parent: "HEAD",
+			parent: childCommitID.Revision(),
 			child:  git.ObjectHashSHA1.ZeroOID.Revision(),
 			errorMatcher: func(t testing.TB, err error) {
 				require.Equal(t, InvalidCommitError(git.ObjectHashSHA1.ZeroOID), err)
@@ -440,14 +453,14 @@ func TestRepo_IsAncestor(t *testing.T) {
 		},
 		{
 			desc:   "child points to a tree",
-			parent: "HEAD",
-			child:  "HEAD^{tree}",
+			parent: childCommitID.Revision(),
+			child:  childCommitID.Revision() + "^{tree}",
 			errorMatcher: func(t testing.TB, actualErr error) {
-				treeOID, err := repo.ResolveRevision(ctx, "HEAD^{tree}")
+				treeOID, err := repo.ResolveRevision(ctx, childCommitID.Revision()+"^{tree}")
 				require.NoError(t, err)
 				require.EqualError(t, actualErr, fmt.Sprintf(
-					`determine ancestry: exit status 128, stderr: "error: object %s is a tree, not a commit\nfatal: Not a valid commit name HEAD^{tree}\n"`,
-					treeOID,
+					`determine ancestry: exit status 128, stderr: "error: object %s is a tree, not a commit\nfatal: Not a valid commit name %s^{tree}\n"`,
+					treeOID, childCommitID,
 				))
 			},
 		},
diff --git a/internal/git/localrepo/refs_test.go b/internal/git/localrepo/refs_test.go
index 1b7ed148f..f061fc810 100644
--- a/internal/git/localrepo/refs_test.go
+++ b/internal/git/localrepo/refs_test.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -29,15 +30,11 @@ import (
 	"google.golang.org/grpc/peer"
 )
 
-const (
-	masterOID      = git.ObjectID("1e292f8fedd741b75372e19097c76d327140c312")
-	nonexistentOID = git.ObjectID("ba4f184e126b751d1bffad5897f263108befc780")
-)
-
 func TestRepo_ContainsRef(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+	gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("master"))
 
 	testcases := []struct {
 		desc      string
@@ -73,7 +70,8 @@ func TestRepo_ContainsRef(t *testing.T) {
 func TestRepo_GetReference(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+	commitID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("master"))
 
 	testcases := []struct {
 		desc        string
@@ -84,7 +82,7 @@ func TestRepo_GetReference(t *testing.T) {
 		{
 			desc:     "fully qualified master branch",
 			ref:      "refs/heads/master",
-			expected: git.NewReference("refs/heads/master", masterOID.String()),
+			expected: git.NewReference("refs/heads/master", commitID.String()),
 		},
 		{
 			desc:        "unqualified master branch fails",
@@ -120,13 +118,10 @@ func TestRepo_GetReference(t *testing.T) {
 func TestRepo_GetReferenceWithAmbiguousRefs(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t, withDisabledHooks())
+	cfg, repo, repoPath := setupRepo(t, withDisabledHooks())
 
-	currentOID, err := repo.ResolveRevision(ctx, "refs/heads/master")
-	require.NoError(t, err)
-
-	prevOID, err := repo.ResolveRevision(ctx, "refs/heads/master~")
-	require.NoError(t, err)
+	prevOID := gittest.WriteCommit(t, cfg, repoPath)
+	currentOID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithParents(prevOID), gittest.WithBranch("master"))
 
 	for _, ref := range []git.ReferenceName{
 		"refs/heads/something/master",
@@ -152,59 +147,65 @@ func TestRepo_GetReferenceWithAmbiguousRefs(t *testing.T) {
 func TestRepo_GetReferences(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
 
-	masterBranch, err := repo.GetReference(ctx, "refs/heads/master")
+	gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"))
+	gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("feature"))
+	gittest.WriteTag(t, cfg, repoPath, "v1.0.0", "refs/heads/main")
+
+	mainReference, err := repo.GetReference(ctx, "refs/heads/main")
+	require.NoError(t, err)
+	featureReference, err := repo.GetReference(ctx, "refs/heads/feature")
+	require.NoError(t, err)
+	tagReference, err := repo.GetReference(ctx, "refs/tags/v1.0.0")
 	require.NoError(t, err)
 
 	testcases := []struct {
-		desc     string
-		patterns []string
-		match    func(t *testing.T, refs []git.Reference)
+		desc         string
+		patterns     []string
+		expectedRefs []git.Reference
 	}{
 		{
-			desc:     "master branch",
-			patterns: []string{"refs/heads/master"},
-			match: func(t *testing.T, refs []git.Reference) {
-				require.Equal(t, []git.Reference{masterBranch}, refs)
+			desc:     "main branch",
+			patterns: []string{"refs/heads/main"},
+			expectedRefs: []git.Reference{
+				mainReference,
 			},
 		},
 		{
 			desc:     "two branches",
-			patterns: []string{"refs/heads/master", "refs/heads/feature"},
-			match: func(t *testing.T, refs []git.Reference) {
-				featureBranch, err := repo.GetReference(ctx, "refs/heads/feature")
-				require.NoError(t, err)
-
-				require.Equal(t, []git.Reference{featureBranch, masterBranch}, refs)
+			patterns: []string{"refs/heads/main", "refs/heads/feature"},
+			expectedRefs: []git.Reference{
+				featureReference,
+				mainReference,
 			},
 		},
 		{
 			desc:     "matching subset is returned",
-			patterns: []string{"refs/heads/master", "refs/heads/nonexistent"},
-			match: func(t *testing.T, refs []git.Reference) {
-				require.Equal(t, []git.Reference{masterBranch}, refs)
+			patterns: []string{"refs/heads/main", "refs/heads/nonexistent"},
+			expectedRefs: []git.Reference{
+				mainReference,
 			},
 		},
 		{
 			desc: "all references",
-			match: func(t *testing.T, refs []git.Reference) {
-				require.Len(t, refs, 97)
+			expectedRefs: []git.Reference{
+				featureReference,
+				mainReference,
+				tagReference,
 			},
 		},
 		{
 			desc:     "branches",
 			patterns: []string{"refs/heads/"},
-			match: func(t *testing.T, refs []git.Reference) {
-				require.Len(t, refs, 94)
+			expectedRefs: []git.Reference{
+				featureReference,
+				mainReference,
 			},
 		},
 		{
 			desc:     "non-existent branch",
 			patterns: []string{"refs/heads/nonexistent"},
-			match: func(t *testing.T, refs []git.Reference) {
-				require.Empty(t, refs)
-			},
 		},
 	}
 
@@ -212,7 +213,7 @@ func TestRepo_GetReferences(t *testing.T) {
 		t.Run(tc.desc, func(t *testing.T) {
 			refs, err := repo.GetReferences(ctx, tc.patterns...)
 			require.NoError(t, err)
-			tc.match(t, refs)
+			require.Equal(t, tc.expectedRefs, refs)
 		})
 	}
 }
@@ -338,21 +339,42 @@ func TestRepo_GetRemoteReferences(t *testing.T) {
 func TestRepo_GetBranches(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+
+	mainID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"), gittest.WithMessage("main"))
+	featureID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("feature"), gittest.WithMessage("feature"))
+	thirdID := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("third"), gittest.WithMessage("third"))
+
+	gittest.WriteCommit(t, cfg, repoPath, gittest.WithReference("refs/different/namespace"))
+	gittest.WriteTag(t, cfg, repoPath, "v1.0.0", mainID.Revision())
 
 	refs, err := repo.GetBranches(ctx)
 	require.NoError(t, err)
-	require.Len(t, refs, 94)
+	require.Equal(t, []git.Reference{
+		{Name: "refs/heads/feature", Target: featureID.String()},
+		{Name: "refs/heads/main", Target: mainID.String()},
+		{Name: "refs/heads/third", Target: thirdID.String()},
+	}, refs)
 }
 
 func TestRepo_UpdateRef(t *testing.T) {
 	ctx := testhelper.Context(t)
 
-	cfg, repo, _ := setupRepo(t, withDisabledHooks())
+	cfg, repo, repoPath := setupRepo(t, withDisabledHooks())
 
-	otherRef, err := repo.GetReference(ctx, "refs/heads/gitaly-test-ref")
+	// We move this into a function so that we can re-seed the repository for each test.
+	seedRepo := func(t *testing.T, repoPath string) {
+		gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"), gittest.WithMessage("main"))
+		gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("other"), gittest.WithMessage("other"))
+	}
+	seedRepo(t, repoPath)
+
+	mainCommitID := gittest.ResolveRevision(t, cfg, repoPath, "refs/heads/main")
+	otherRef, err := repo.GetReference(ctx, "refs/heads/other")
 	require.NoError(t, err)
 
+	nonexistentOID := git.ObjectID(strings.Repeat("1", gittest.DefaultObjectHash.EncodedLen()))
+
 	testcases := []struct {
 		desc     string
 		ref      string
@@ -361,95 +383,98 @@ func TestRepo_UpdateRef(t *testing.T) {
 		verify   func(t *testing.T, repo *Repo, err error)
 	}{
 		{
-			desc:     "successfully update master",
-			ref:      "refs/heads/master",
+			desc:     "successfully update main",
+			ref:      "refs/heads/main",
 			newValue: git.ObjectID(otherRef.Target),
-			oldValue: masterOID,
+			oldValue: mainCommitID,
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.NoError(t, err)
-				ref, err := repo.GetReference(ctx, "refs/heads/master")
+				ref, err := repo.GetReference(ctx, "refs/heads/main")
 				require.NoError(t, err)
 				require.Equal(t, ref.Target, otherRef.Target)
 			},
 		},
 		{
 			desc:     "update fails with stale oldValue",
-			ref:      "refs/heads/master",
+			ref:      "refs/heads/main",
 			newValue: git.ObjectID(otherRef.Target),
 			oldValue: nonexistentOID,
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.Error(t, err)
-				ref, err := repo.GetReference(ctx, "refs/heads/master")
+				ref, err := repo.GetReference(ctx, "refs/heads/main")
 				require.NoError(t, err)
-				require.Equal(t, ref.Target, masterOID.String())
+				require.Equal(t, ref.Target, mainCommitID.String())
 			},
 		},
 		{
 			desc:     "update fails with invalid newValue",
-			ref:      "refs/heads/master",
+			ref:      "refs/heads/main",
 			newValue: nonexistentOID,
-			oldValue: masterOID,
+			oldValue: mainCommitID,
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.Error(t, err)
-				ref, err := repo.GetReference(ctx, "refs/heads/master")
+				ref, err := repo.GetReference(ctx, "refs/heads/main")
 				require.NoError(t, err)
-				require.Equal(t, ref.Target, masterOID.String())
+				require.Equal(t, ref.Target, mainCommitID.String())
 			},
 		},
 		{
-			desc:     "successfully update master with empty oldValue",
-			ref:      "refs/heads/master",
+			desc:     "successfully update main with empty oldValue",
+			ref:      "refs/heads/main",
 			newValue: git.ObjectID(otherRef.Target),
 			oldValue: "",
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.NoError(t, err)
-				ref, err := repo.GetReference(ctx, "refs/heads/master")
+				ref, err := repo.GetReference(ctx, "refs/heads/main")
 				require.NoError(t, err)
 				require.Equal(t, ref.Target, otherRef.Target)
 			},
 		},
 		{
 			desc:     "updating unqualified branch fails",
-			ref:      "master",
+			ref:      "main",
 			newValue: git.ObjectID(otherRef.Target),
-			oldValue: masterOID,
+			oldValue: mainCommitID,
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.Error(t, err)
-				ref, err := repo.GetReference(ctx, "refs/heads/master")
+				ref, err := repo.GetReference(ctx, "refs/heads/main")
 				require.NoError(t, err)
-				require.Equal(t, ref.Target, masterOID.String())
+				require.Equal(t, ref.Target, mainCommitID.String())
 			},
 		},
 		{
-			desc:     "deleting master succeeds",
-			ref:      "refs/heads/master",
+			desc:     "deleting main succeeds",
+			ref:      "refs/heads/main",
 			newValue: git.ObjectHashSHA1.ZeroOID,
-			oldValue: masterOID,
+			oldValue: mainCommitID,
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.NoError(t, err)
-				_, err = repo.GetReference(ctx, "refs/heads/master")
+				_, err = repo.GetReference(ctx, "refs/heads/main")
 				require.Error(t, err)
 			},
 		},
 		{
 			desc:     "creating new branch succeeds",
 			ref:      "refs/heads/new",
-			newValue: masterOID,
+			newValue: mainCommitID,
 			oldValue: git.ObjectHashSHA1.ZeroOID,
 			verify: func(t *testing.T, repo *Repo, err error) {
 				require.NoError(t, err)
 				ref, err := repo.GetReference(ctx, "refs/heads/new")
 				require.NoError(t, err)
-				require.Equal(t, ref.Target, masterOID.String())
+				require.Equal(t, ref.Target, mainCommitID.String())
 			},
 		},
 	}
 
 	for _, tc := range testcases {
 		t.Run(tc.desc, func(t *testing.T) {
-			// Re-create repo for each testcase.
-			repoProto, _ := gittest.CloneRepo(t, cfg, cfg.Storages[0])
+			// We need to re-seed the repository every time so that we don't carry over
+			// the state.
+			repoProto, repoPath := gittest.InitRepo(t, cfg, cfg.Storages[0])
 			repo := New(repo.locator, repo.gitCmdFactory, repo.catfileCache, repoProto)
+			seedRepo(t, repoPath)
+
 			err := repo.UpdateRef(ctx, git.ReferenceName(tc.ref), tc.newValue, tc.oldValue)
 			tc.verify(t, repo, err)
 		})
@@ -458,7 +483,10 @@ func TestRepo_UpdateRef(t *testing.T) {
 
 func TestRepo_SetDefaultBranch(t *testing.T) {
 	ctx := testhelper.Context(t)
-	_, repo, _ := setupRepo(t)
+	cfg, repo, repoPath := setupRepo(t)
+
+	gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("master"))
+	gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("feature"))
 
 	txManager := transaction.NewTrackingManager()
 
@@ -620,8 +648,8 @@ func TestRepo_SetDefaultBranch_errors(t *testing.T) {
 func TestGuessHead(t *testing.T) {
 	cfg, repo, repoPath := setupRepo(t)
 
-	commit1 := text.ChompBytes(gittest.Exec(t, cfg, "-C", repoPath, "rev-parse", "refs/heads/master"))
-	commit2 := text.ChompBytes(gittest.Exec(t, cfg, "-C", repoPath, "rev-parse", "refs/heads/feature"))
+	commit1 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("main"), gittest.WithMessage("main"))
+	commit2 := gittest.WriteCommit(t, cfg, repoPath, gittest.WithBranch("feature"), gittest.WithMessage("feature"))
 
 	for _, tc := range []struct {
 		desc        string
@@ -638,37 +666,37 @@ func TestGuessHead(t *testing.T) {
 		{
 			desc: "matching default branch",
 			cmds: [][]string{
-				{"update-ref", git.DefaultRef.String(), commit1},
-				{"update-ref", git.LegacyDefaultRef.String(), commit2},
-				{"update-ref", "refs/heads/apple", commit1},
-				{"update-ref", "refs/heads/feature", commit1},
-				{"update-ref", "refs/heads/zucchini", commit1},
+				{"update-ref", git.DefaultRef.String(), commit1.String()},
+				{"update-ref", git.LegacyDefaultRef.String(), commit2.String()},
+				{"update-ref", "refs/heads/apple", commit1.String()},
+				{"update-ref", "refs/heads/feature", commit1.String()},
+				{"update-ref", "refs/heads/zucchini", commit1.String()},
 			},
-			head:     git.NewReference("HEAD", commit1),
+			head:     git.NewReference("HEAD", commit1.String()),
 			expected: git.DefaultRef,
 		},
 		{
 			desc: "matching default legacy branch",
 			cmds: [][]string{
-				{"update-ref", git.DefaultRef.String(), commit2},
-				{"update-ref", git.LegacyDefaultRef.String(), commit1},
-				{"update-ref", "refs/heads/apple", commit1},
-				{"update-ref", "refs/heads/feature", commit1},
-				{"update-ref", "refs/heads/zucchini", commit1},
+				{"update-ref", git.DefaultRef.String(), commit2.String()},
+				{"update-ref", git.LegacyDefaultRef.String(), commit1.String()},
+				{"update-ref", "refs/heads/apple", commit1.String()},
+				{"update-ref", "refs/heads/feature", commit1.String()},
+				{"update-ref", "refs/heads/zucchini", commit1.String()},
 			},
-			head:     git.NewReference("HEAD", commit1),
+			head:     git.NewReference("HEAD", commit1.String()),
 			expected: git.LegacyDefaultRef,
 		},
 		{
 			desc: "matching other branch",
 			cmds: [][]string{
-				{"update-ref", git.DefaultRef.String(), commit2},
-				{"update-ref", git.LegacyDefaultRef.String(), commit2},
-				{"update-ref", "refs/heads/apple", commit1},
-				{"update-ref", "refs/heads/feature", commit1},
-				{"update-ref", "refs/heads/zucchini", commit1},
+				{"update-ref", git.DefaultRef.String(), commit2.String()},
+				{"update-ref", git.LegacyDefaultRef.String(), commit2.String()},
+				{"update-ref", "refs/heads/apple", commit1.String()},
+				{"update-ref", "refs/heads/feature", commit1.String()},
+				{"update-ref", "refs/heads/zucchini", commit1.String()},
 			},
-			head:     git.NewReference("HEAD", commit1),
+			head:     git.NewReference("HEAD", commit1.String()),
 			expected: "refs/heads/apple",
 		},
 		{
@@ -676,23 +704,23 @@ func TestGuessHead(t *testing.T) {
 			cmds: [][]string{
 				{"update-ref", "-d", git.DefaultRef.String()},
 				{"update-ref", "-d", git.LegacyDefaultRef.String()},
-				{"update-ref", "refs/heads/apple", commit1},
-				{"update-ref", "refs/heads/feature", commit1},
-				{"update-ref", "refs/heads/zucchini", commit1},
+				{"update-ref", "refs/heads/apple", commit1.String()},
+				{"update-ref", "refs/heads/feature", commit1.String()},
+				{"update-ref", "refs/heads/zucchini", commit1.String()},
 			},
-			head:     git.NewReference("HEAD", commit1),
+			head:     git.NewReference("HEAD", commit1.String()),
 			expected: "refs/heads/apple",
 		},
 		{
 			desc: "no match",
 			cmds: [][]string{
-				{"update-ref", git.DefaultRef.String(), commit2},
-				{"update-ref", git.LegacyDefaultRef.String(), commit2},
-				{"update-ref", "refs/heads/apple", commit2},
-				{"update-ref", "refs/heads/feature", commit2},
-				{"update-ref", "refs/heads/zucchini", commit2},
+				{"update-ref", git.DefaultRef.String(), commit2.String()},
+				{"update-ref", git.LegacyDefaultRef.String(), commit2.String()},
+				{"update-ref", "refs/heads/apple", commit2.String()},
+				{"update-ref", "refs/heads/feature", commit2.String()},
+				{"update-ref", "refs/heads/zucchini", commit2.String()},
 			},
-			head:        git.NewReference("HEAD", commit1),
+			head:        git.NewReference("HEAD", commit1.String()),
 			expectedErr: fmt.Errorf("guess head: %w", git.ErrReferenceNotFound),
 		},
 	} {
diff --git a/internal/git/localrepo/testhelper_test.go b/internal/git/localrepo/testhelper_test.go
index 8fb0bd4f7..a331cbf82 100644
--- a/internal/git/localrepo/testhelper_test.go
+++ b/internal/git/localrepo/testhelper_test.go
@@ -11,7 +11,6 @@ import (
 	"gitlab.com/gitlab-org/gitaly/v15/internal/gitaly/config"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/testhelper"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/testhelper/testcfg"
-	"gitlab.com/gitlab-org/gitaly/v15/proto/go/gitalypb"
 )
 
 func TestMain(m *testing.M) {
@@ -19,21 +18,12 @@ func TestMain(m *testing.M) {
 }
 
 type setupRepoConfig struct {
-	// emptyRepo will cause `setupRepo()` to create a new, empty repository instead of
-	// cloning our test repository.
-	emptyRepo bool
 	// disableHooks will disable the use of hooks.
 	disableHooks bool
 }
 
 type setupRepoOption func(*setupRepoConfig)
 
-func withEmptyRepo() setupRepoOption {
-	return func(cfg *setupRepoConfig) {
-		cfg.emptyRepo = true
-	}
-}
-
 func withDisabledHooks() setupRepoOption {
 	return func(cfg *setupRepoConfig) {
 		cfg.disableHooks = true
@@ -55,13 +45,7 @@ func setupRepo(t *testing.T, opts ...setupRepoOption) (config.Cfg, *Repo, string
 		commandFactoryOpts = append(commandFactoryOpts, git.WithSkipHooks())
 	}
 
-	var repoProto *gitalypb.Repository
-	var repoPath string
-	if setupRepoCfg.emptyRepo {
-		repoProto, repoPath = gittest.InitRepo(t, cfg, cfg.Storages[0])
-	} else {
-		repoProto, repoPath = gittest.CloneRepo(t, cfg, cfg.Storages[0])
-	}
+	repoProto, repoPath := gittest.InitRepo(t, cfg, cfg.Storages[0])
 
 	gitCmdFactory := gittest.NewCommandFactory(t, cfg, commandFactoryOpts...)
 	catfileCache := catfile.NewCache(cfg)