Skip to content

Git designed for AI agents.

23.5 KB
Raw Blame
package commit

import (
	"context"
	"fmt"
	"path/filepath"
	"strings"
	"testing"

	"github.com/feder-cr/git-ai/internal/featureflag"
	"github.com/feder-cr/git-ai/internal/git"
	"github.com/feder-cr/git-ai/internal/git/gittest"
	"github.com/feder-cr/git-ai/internal/git/localrepo"
	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/internal/gitaly/storage"
	"github.com/feder-cr/git-ai/internal/helper/text"
	"github.com/feder-cr/git-ai/internal/structerr"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/feder-cr/git-ai/internal/testhelper/testcfg"
	"github.com/feder-cr/git-ai/proto/go/gitalypb"
	"github.com/stretchr/testify/require"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

const (
	pgpSignature = `-----BEGIN PGP SIGNATURE-----
Version: ObjectivePGP
Comment: https://www.objectivepgp.com
Charset: UTF-8

wsFcBAABCgAGBQJecon1AAoJEDYMjTn1G2THmSsP/At/jskLdF0i7p0nKf4JLjeeqRJ4k2IUg87U
ZwV6mbLo5XFm8Sq7CJBAGAhlOZE4BAwKALuawmgs5XMEZwK2z6AIgosGTVpmxDTTI11bXt4XIOdz
qF7c/gUrJOZzjFXOqDsd5UuPRupwznC5eKlLbfImR+NYxKryo8JGdF5t52ph4kChcQsKlSkXuYNI
+9UgbaMclEjb0OLm+mcP9QxW+Cs9JS2Jb4Jh6XONWW1nDN3ZTDDskguIqqF47UxIgSImrmpMcEj9
YSNU0oMoHM4+1DoXp1t99EGPoAMvO+a5g8gd1jouCIrI6KOX+GeG/TFFM0mQwg/d/N9LR049m8ed
vgqg/lMiWUxQGL2IPpYPcgiUEqfn7ete+NMzQV5zstxF/q7Yj2BhM2L7FPHxKaoy/w5Q/DcAO4wN
5gxVmIvbCDk5JOx8I+boIS8ZxSvIlJ5IWaPrcjg5Mc40it+WHvMqxVnCzH0c6KcXaJ2SibVb59HR
pdRhEXXw/hRN65l/xwyM8sklQalAGu755gNJZ4k9ApBVUssZyiu+te2+bDirAcmK8/x1jvMQY6bn
DFxBE7bMHDp24IFPaVID84Ryt3vSSBEkrUGm7OkyDESTpHCr4sfD5o3LCUCIibTqv/CAhe59mhbB
2AXL7X+EzylKy6C1N5KUUiMTW94AuF6f8FqBoxnf
=U6zM
-----END PGP SIGNATURE-----`

	sshSignature = `-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtc+Qk8jhMwVZk/jFEFCM16LNQb
30q5kK30bbetfjyTMAAAADZ2l0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5
AAAAQADE1oOMKxqQu86XUQbhCoWx8GnnYHQ/i3mHdA0zPycIlDv8N6BRVDS6b0ja2Avj+s
uNvjRqSEGQJ4q6vhKOnQw=
-----END SSH SIGNATURE-----`
)

func TestGetCommitSignatures(t *testing.T) {
	t.Parallel()
	testhelper.NewFeatureSets(featureflag.GPGSigning).Run(t, testGetCommitSignatures)
}

func testGetCommitSignatures(t *testing.T, ctx context.Context) {
	type setupData struct {
		request           *gitalypb.GetCommitSignaturesRequest
		expectedErr       error
		expectedResponses []*gitalypb.GetCommitSignaturesResponse
	}

	type TestData struct {
		cfg       config.Cfg
		repoProto *gitalypb.Repository
		repoPath  string
	}

	for _, tc := range []struct {
		desc  string
		setup func(t *testing.T, data TestData) setupData
	}{
		{
			desc: "unset repository",
			setup: func(t *testing.T, data TestData) setupData {
				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: nil,
						CommitIds:  []string{"5937ac0a7beb003549fc5fd26fc247adbce4a52e"},
					},
					expectedErr: structerr.NewInvalidArgument("%w", storage.ErrRepositoryNotSet),
				}
			},
		},
		{
			desc: "unset commit IDs",
			setup: func(t *testing.T, data TestData) setupData {
				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds:  []string{},
					},
					expectedErr: status.Error(codes.InvalidArgument, "empty CommitIds"),
				}
			},
		},
		{
			desc: "abbreviated commit ID",
			setup: func(t *testing.T, data TestData) setupData {
				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							gittest.DefaultObjectHash.HashData([]byte("pseudo commit")).String(),
							"a17a9f6",
						},
					},
					expectedErr: structerr.NewInvalidArgument(`invalid object ID: "a17a9f6", expected length %v, got 7`, gittest.DefaultObjectHash.EncodedLen()),
				}
			},
		},
		{
			desc: "nonexistent commit",
			setup: func(t *testing.T, data TestData) setupData {
				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							gittest.DefaultObjectHash.HashData([]byte("nonexistent commit")).String(),
						},
					},
				}
			},
		},
		{
			desc: "unsigned commit",
			setup: func(t *testing.T, data TestData) setupData {
				commitID := gittest.WriteCommit(t, data.cfg, data.repoPath)

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
				}
			},
		},
		{
			desc: "PGP-signed commit",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig", pgpSignature, "Signed commit message\n")

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(pgpSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "PGP-signed commit with message lacking newline",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig", pgpSignature, "Signed commit message")

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(pgpSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "PGP-signed commit with huge commit message",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig", pgpSignature, strings.Repeat("a", 5*1024*1024))

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(pgpSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "SSH-signed commit",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig", sshSignature, "SSH-signed commit message\n")

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(sshSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "garbage-signed commit",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, _ := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig-garbage", sshSignature, "garbage-signed commit message")

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
				}
			},
		},
		{
			desc: "SHA256-signed commit",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig-sha256", sshSignature, "sha256-signed commit message")

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(sshSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "commit with different author and committer",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithDifferentAuthorCommitter(
					t, data.cfg, data.repoPath,
					"gpgsig", pgpSignature,
					"Different author/committer commit",
				)

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds:  []string{commitID.String()},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(pgpSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "commit mailmapped committer",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithDifferentAuthorCommitter(
					t, data.cfg, data.repoPath,
					"gpgsig", pgpSignature,
					"Commit with original committer",
				)

				mailmapContents := "Mapped Committer <[email protected]> Different Committer <[email protected]>"
				gittest.WriteCommit(t, data.cfg, data.repoPath, gittest.WithTreeEntries(
					gittest.TreeEntry{Path: ".mailmap", Mode: "100644", Content: mailmapContents},
				), gittest.WithBranch("main"))

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds:  []string{commitID.String()},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(pgpSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"), // Original committer (unmailmapped)
							},
						},
					},
				}
			},
		},
		{
			desc: "signed by Gitaly",
			setup: func(t *testing.T, data TestData) setupData {
				repo := localrepo.NewTestRepo(t, data.cfg, data.repoProto)

				blobID := gittest.WriteBlob(t, data.cfg, data.repoPath, []byte("updated"))

				tree := &localrepo.TreeEntry{
					Type: localrepo.Tree,
					Mode: "040000",
					Entries: []*localrepo.TreeEntry{
						{Path: "file", Mode: "100644", OID: blobID},
					},
				}
				require.NoError(t, tree.Write(ctx, repo))

				commitID, err := repo.WriteCommit(ctx, localrepo.WriteCommitConfig{
					TreeID:         tree.OID,
					AuthorName:     gittest.DefaultCommitterName,
					AuthorEmail:    gittest.DefaultCommitterMail,
					CommitterName:  gittest.DefaultCommitterName,
					CommitterEmail: gittest.DefaultCommitterMail,
					AuthorDate:     gittest.DefaultCommitTime,
					CommitterDate:  gittest.DefaultCommitTime,
					Message:        "message",
					GitConfig:      data.cfg.Git,
					Sign:           featureflag.GPGSigning.IsEnabled(ctx),
				})
				require.NoError(t, err)

				rotatedKeyCommitID, err := repo.WriteCommit(ctx, localrepo.WriteCommitConfig{
					TreeID:         tree.OID,
					AuthorName:     gittest.DefaultCommitterName,
					AuthorEmail:    gittest.DefaultCommitterMail,
					CommitterName:  gittest.DefaultCommitterName,
					CommitterEmail: gittest.DefaultCommitterMail,
					AuthorDate:     gittest.DefaultCommitTime,
					CommitterDate:  gittest.DefaultCommitTime,
					Message:        "rotated key commit message",
					GitConfig: config.Git{
						SigningKey: data.cfg.Git.RotatedSigningKeys[0],
					},
					Sign: featureflag.GPGSigning.IsEnabled(ctx),
				})
				require.NoError(t, err)

				rsaSHA1Signature := string(testhelper.MustReadFile(t, "testdata/signing_ssh_key_rsa.sig"))
				rsaSHA256Signature := string(testhelper.MustReadFile(t, "testdata/signing_ssh_key_rsa_sha256.sig"))
				ed25519SHA1Signature := string(testhelper.MustReadFile(t, "testdata/signing_ssh_key_ed25519.sig"))
				ed25519SHA256Signature := string(testhelper.MustReadFile(t, "testdata/signing_ssh_key_ed25519_sha256.sig"))

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
							rotatedKeyCommitID.String(),
						},
					},
					expectedResponses: testhelper.EnabledOrDisabledFlag(ctx, featureflag.GPGSigning,
						[]*gitalypb.GetCommitSignaturesResponse{
							{
								CommitId: commitID.String(),
								Signature: []byte(gittest.ObjectHashDependent(t, map[string]string{
									"sha1":   ed25519SHA1Signature,
									"sha256": ed25519SHA256Signature,
								})),
								SignedText: []byte(fmt.Sprintf(
									"tree %s\nauthor %s\ncommitter %s\n\nmessage",
									tree.OID,
									gittest.DefaultCommitterSignature,
									gittest.DefaultCommitterSignature,
								)),
								Signer: gitalypb.GetCommitSignaturesResponse_SIGNER_SYSTEM,
								Author: &gitalypb.CommitAuthor{
									Email: []byte("[email protected]"),
								},
								Committer: &gitalypb.CommitAuthor{
									Email: []byte("[email protected]"),
								},
							},
							{
								CommitId: rotatedKeyCommitID.String(),
								Signature: []byte(gittest.ObjectHashDependent(t, map[string]string{
									"sha1":   rsaSHA1Signature,
									"sha256": rsaSHA256Signature,
								})),
								SignedText: []byte(fmt.Sprintf(
									"tree %s\nauthor %s\ncommitter %s\n\nrotated key commit message",
									tree.OID,
									gittest.DefaultCommitterSignature,
									gittest.DefaultCommitterSignature,
								)),
								Signer: gitalypb.GetCommitSignaturesResponse_SIGNER_SYSTEM,
								Author: &gitalypb.CommitAuthor{
									Email: []byte("[email protected]"),
								},
								Committer: &gitalypb.CommitAuthor{
									Email: []byte("[email protected]"),
								},
							},
						},
						nil,
					),
				}
			},
		},
		{
			desc: "commit signed before mailmap entry",
			setup: func(t *testing.T, data TestData) setupData {
				commitID, commitData := createCommitWithSignature(t, data.cfg, data.repoPath, "gpgsig", pgpSignature, "Signed commit message\n")

				mailmapContents := "A U Thor <[email protected]> Bug Fixer <[email protected]>"
				gittest.WriteCommit(t, data.cfg, data.repoPath, gittest.WithTreeEntries(
					gittest.TreeEntry{Path: ".mailmap", Mode: "100644", Content: mailmapContents},
				), gittest.WithBranch("main"))

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: []*gitalypb.GetCommitSignaturesResponse{
						{
							CommitId:   commitID.String(),
							Signature:  []byte(pgpSignature),
							SignedText: []byte(commitData),
							Signer:     gitalypb.GetCommitSignaturesResponse_SIGNER_USER,
							Author: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
							Committer: &gitalypb.CommitAuthor{
								Email: []byte("[email protected]"),
							},
						},
					},
				}
			},
		},
		{
			desc: "commit signed by gitaly before mailmap entry",
			setup: func(t *testing.T, data TestData) setupData {
				repo := localrepo.NewTestRepo(t, data.cfg, data.repoProto)

				blobID := gittest.WriteBlob(t, data.cfg, data.repoPath, []byte("updated"))

				tree := &localrepo.TreeEntry{
					Type: localrepo.Tree,
					Mode: "040000",
					Entries: []*localrepo.TreeEntry{
						{Path: "file", Mode: "100644", OID: blobID},
					},
				}
				require.NoError(t, tree.Write(ctx, repo))

				commitID, err := repo.WriteCommit(ctx, localrepo.WriteCommitConfig{
					TreeID:         tree.OID,
					AuthorName:     gittest.DefaultCommitterName,
					AuthorEmail:    gittest.DefaultCommitterMail,
					CommitterName:  gittest.DefaultCommitterName,
					CommitterEmail: gittest.DefaultCommitterMail,
					AuthorDate:     gittest.DefaultCommitTime,
					CommitterDate:  gittest.DefaultCommitTime,
					Message:        "message",
					GitConfig:      data.cfg.Git,
					Sign:           featureflag.GPGSigning.IsEnabled(ctx),
				})
				require.NoError(t, err)

				mailmapContents := "A U Thor <[email protected]> Scrooge McDuck <[email protected]>"
				gittest.WriteCommit(t, data.cfg, data.repoPath, gittest.WithTreeEntries(
					gittest.TreeEntry{Path: ".mailmap", Mode: "100644", Content: mailmapContents},
				), gittest.WithBranch("main"))

				ed25519SHA1Signature := string(testhelper.MustReadFile(t, "testdata/signing_ssh_key_ed25519.sig"))
				ed25519SHA256Signature := string(testhelper.MustReadFile(t, "testdata/signing_ssh_key_ed25519_sha256.sig"))

				return setupData{
					request: &gitalypb.GetCommitSignaturesRequest{
						Repository: data.repoProto,
						CommitIds: []string{
							commitID.String(),
						},
					},
					expectedResponses: testhelper.EnabledOrDisabledFlag(ctx, featureflag.GPGSigning,
						[]*gitalypb.GetCommitSignaturesResponse{
							{
								CommitId: commitID.String(),
								Signature: []byte(gittest.ObjectHashDependent(t, map[string]string{
									"sha1":   ed25519SHA1Signature,
									"sha256": ed25519SHA256Signature,
								})),
								SignedText: []byte(fmt.Sprintf(
									"tree %s\nauthor %s\ncommitter %s\n\nmessage",
									tree.OID,
									gittest.DefaultCommitterSignature,
									gittest.DefaultCommitterSignature,
								)),
								Signer: gitalypb.GetCommitSignaturesResponse_SIGNER_SYSTEM,
								Author: &gitalypb.CommitAuthor{
									Email: []byte("[email protected]"),
								},
								Committer: &gitalypb.CommitAuthor{
									Email: []byte("[email protected]"),
								},
							},
						},
						nil,
					),
				}
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			t.Parallel()

			cfg := testcfg.Build(t)
			testcfg.BuildGitalyGPG(t, cfg)

			cfg.Git.SigningKey = filepath.Join(testhelper.TestdataAbsolutePath(t), "signing_ssh_key_ed25519")
			cfg.Git.RotatedSigningKeys = []string{filepath.Join(testhelper.TestdataAbsolutePath(t), "signing_ssh_key_rsa")}
			cfg.SocketPath = startTestServices(t, cfg)
			client := newCommitServiceClient(t, cfg.SocketPath)

			repoProto, repoPath := gittest.CreateRepository(t, ctx, cfg)

			setup := tc.setup(t, TestData{
				cfg:       cfg,
				repoProto: repoProto,
				repoPath:  repoPath,
			})

			stream, err := client.GetCommitSignatures(ctx, setup.request)
			require.NoError(t, err)

			actualResponses, err := testhelper.ReceiveAndFold(stream.Recv, func(
				result []*gitalypb.GetCommitSignaturesResponse,
				response *gitalypb.GetCommitSignaturesResponse,
			) []*gitalypb.GetCommitSignaturesResponse {
				// We don't need to do any fiddling when we have a commit ID, which would signify
				// another returned commit.
				if response.GetCommitId() != "" {
					return append(result, response)
				}

				// But when we don't have a commit ID we append both the signature and signed text so
				// that it becomes easier to test for these values, as they might otherwise be split.
				currentResponse := result[len(result)-1]
				currentResponse.Signature = append(currentResponse.Signature, response.GetSignature()...)
				currentResponse.SignedText = append(currentResponse.SignedText, response.GetSignedText()...)

				return result
			})
			testhelper.RequireGrpcError(t, setup.expectedErr, err)

			require.Len(t, actualResponses, len(setup.expectedResponses))
			for i, expected := range setup.expectedResponses {
				// We cannot use `testhelper.ProtoEqual` here due to it being too inefficient with
				// the data we're comparing because it contains multiple MB of signed data. This has
				// in the past led to frequent timeouts in CI.
				require.Equal(t, expected.GetCommitId(), actualResponses[i].GetCommitId())
				require.Equal(t, string(expected.GetSignature()), string(actualResponses[i].GetSignature()))
				require.Equal(t, string(expected.GetSignedText()), string(actualResponses[i].GetSignedText()))
				require.Equal(t, string(expected.GetSigner()), string(actualResponses[i].GetSigner()))
				// It's sufficient to check if the email holds true since that is what we're most
				// concerned about, because 'mailmap' could swap it out.
				require.Equal(t, expected.GetAuthor().GetEmail(), actualResponses[i].GetAuthor().GetEmail())
			}
		})
	}
}

func createCommitWithSignature(t *testing.T, cfg config.Cfg, repoPath, signatureField, signature, commitMessage string) (git.ObjectID, string) {
	// Each line of the signature needs to start with a space so that Git recognizes it as a continuation of the
	// field.
	signatureLines := strings.Split(signature, "\n")
	for i, signatureLine := range signatureLines {
		signatureLines[i] = " " + signatureLine
	}

	commitData := fmt.Sprintf(`tree %s
author Bug Fixer <[email protected]> 1584564725 +0100
committer Bug Fixer <[email protected]> 1584564725 +0100

%s
`, gittest.DefaultObjectHash.EmptyTreeOID, commitMessage)

	signedCommitData := strings.Replace(commitData, "\n\n", fmt.Sprintf("\n%s%s\n\n", signatureField, strings.Join(signatureLines, "\n")), 1)

	stdout := gittest.ExecOpts(t, cfg, gittest.ExecConfig{
		Stdin: strings.NewReader(signedCommitData),
	}, "-C", repoPath, "hash-object", "-w", "-t", "commit", "--stdin", "--literally")

	commitID, err := gittest.DefaultObjectHash.FromHex(text.ChompBytes(stdout))
	require.NoError(t, err)

	return commitID, commitData
}

func createCommitWithDifferentAuthorCommitter(t *testing.T, cfg config.Cfg, repoPath, signatureField, signature, commitMessage string) (git.ObjectID, string) {
	signatureLines := strings.Split(signature, "\n")
	for i, signatureLine := range signatureLines {
		signatureLines[i] = " " + signatureLine
	}

	commitData := fmt.Sprintf(`tree %s
author Original Author <[email protected]> 1584564725 +0100
committer Different Committer <[email protected]> 1584564725 +0100

%s
`, gittest.DefaultObjectHash.EmptyTreeOID, commitMessage)

	signedCommitData := strings.Replace(commitData, "\n\n", fmt.Sprintf("\n%s%s\n\n", signatureField, strings.Join(signatureLines, "\n")), 1)

	stdout := gittest.ExecOpts(t, cfg, gittest.ExecConfig{
		Stdin: strings.NewReader(signedCommitData),
	}, "-C", repoPath, "hash-object", "-w", "-t", "commit", "--stdin", "--literally")

	commitID, err := gittest.DefaultObjectHash.FromHex(text.ChompBytes(stdout))
	require.NoError(t, err)

	return commitID, commitData
}