ref: Refactor ListTagNamesContainingCommits tests

Refactor tests for the ListTagNamesContainingCommits RPC to conform to
our modern best practices. Most importantly, refactor it so that we
don't use a seed repository anymore but instead generate test data at
runtime. This also allows us to be more thorough with our testing where
we don't need to use a subset-test anymore, but can instead test for
equivalence of expected and actual results.

1 files changed, 91 insertions, 73 deletions

diff --git a/internal/gitaly/service/ref/refnames_containing_test.go b/internal/gitaly/service/ref/refnames_containing_test.go
index 6a8236ca9..6e60ba45f 100644
--- a/internal/gitaly/service/ref/refnames_containing_test.go
+++ b/internal/gitaly/service/ref/refnames_containing_test.go
@@ -3,12 +3,15 @@
 package ref
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"gitlab.com/gitlab-org/gitaly/v15/internal/git"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/git/gittest"
+	"gitlab.com/gitlab-org/gitaly/v15/internal/structerr"
 	"gitlab.com/gitlab-org/gitaly/v15/internal/testhelper"
 	"gitlab.com/gitlab-org/gitaly/v15/proto/go/gitalypb"
 	"google.golang.org/grpc/codes"
@@ -19,101 +22,116 @@ func TestListTagNamesContainingCommit(t *testing.T) {
 	t.Parallel()
 
 	ctx := testhelper.Context(t)
-	_, repoProto, _, client := setupRefService(t, ctx)
+	cfg, client := setupRefServiceWithoutRepo(t)
 
-	testCases := []struct {
-		description string
-		commitID    string
-		code        codes.Code
-		limit       uint32
-		tags        []string
+	repo, repoPath := gittest.CreateRepository(t, ctx, cfg)
+
+	commitA := gittest.WriteCommit(t, cfg, repoPath)
+	commitB := gittest.WriteCommit(t, cfg, repoPath, gittest.WithParents(commitA))
+	commitC := gittest.WriteCommit(t, cfg, repoPath, gittest.WithParents(commitB), gittest.WithBranch(git.DefaultBranch))
+
+	gittest.WriteTag(t, cfg, repoPath, "annotated", commitA.Revision(), gittest.WriteTagConfig{
+		Message: "annotated",
+	})
+	gittest.WriteTag(t, cfg, repoPath, "lightweight", commitB.Revision())
+
+	for _, tc := range []struct {
+		desc         string
+		request      *gitalypb.ListTagNamesContainingCommitRequest
+		expectedErr  error
+		expectedTags []string
 	}{
 		{
-			description: "no commit ID",
-			commitID:    "",
-			code:        codes.InvalidArgument,
+			desc: "repository not provided",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: nil,
+			},
+			expectedErr: structerr.NewInvalidArgument(testhelper.GitalyOrPraefect(
+				"empty Repository",
+				"repo scoped: empty Repository",
+			)),
 		},
 		{
-			description: "current master HEAD",
-			commitID:    "e63f41fe459e62e1228fcef60d7189127aeba95a",
-			code:        codes.OK,
-			tags:        []string{},
+			desc: "invalid commit ID",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: repo,
+				CommitId:   "invalid",
+			},
+			expectedErr: structerr.NewInvalidArgument(
+				fmt.Sprintf(`invalid object ID: "invalid", expected length %v, got 7`, gittest.DefaultObjectHash.EncodedLen()),
+			),
 		},
 		{
-			description: "init commit",
-			commitID:    "1a0b36b3cdad1d2ee32457c102a8c0b7056fa863",
-			code:        codes.OK,
-			tags:        []string{"v1.0.0", "v1.1.0"},
+			desc: "no commit ID",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: repo,
+				CommitId:   "",
+			},
+			expectedErr: structerr.NewInvalidArgument(
+				`invalid object ID: "", expected length %d, got 0`, gittest.DefaultObjectHash.EncodedLen(),
+			),
 		},
 		{
-			description: "limited response size",
-			commitID:    "1a0b36b3cdad1d2ee32457c102a8c0b7056fa863",
-			code:        codes.OK,
-			limit:       1,
-			tags:        []string{"v1.0.0"},
+			desc: "commit not contained in any tag",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: repo,
+				CommitId:   commitC.String(),
+			},
+			expectedTags: nil,
 		},
-	}
+		{
+			desc: "root commit",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: repo,
+				CommitId:   commitA.String(),
+			},
+			expectedTags: []string{"annotated", "lightweight"},
+		},
+		{
+			desc: "root commit with limit",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: repo,
+				CommitId:   commitA.String(),
+				Limit:      1,
+			},
+			expectedTags: []string{"annotated"},
+		},
+		{
+			desc: "commit with single tag",
+			request: &gitalypb.ListTagNamesContainingCommitRequest{
+				Repository: repo,
+				CommitId:   commitB.String(),
+			},
+			expectedTags: []string{"lightweight"},
+		},
+	} {
+		tc := tc
 
-	for _, tc := range testCases {
-		t.Run(tc.description, func(t *testing.T) {
-			request := &gitalypb.ListTagNamesContainingCommitRequest{Repository: repoProto, CommitId: tc.commitID}
+		t.Run(tc.desc, func(t *testing.T) {
+			t.Parallel()
 
-			c, err := client.ListTagNamesContainingCommit(ctx, request)
+			stream, err := client.ListTagNamesContainingCommit(ctx, tc.request)
 			require.NoError(t, err)
 
-			var names []string
+			var tagNames []string
 			for {
-				r, err := c.Recv()
-				if err == io.EOF {
-					break
-				} else if tc.code != codes.OK {
-					testhelper.RequireGrpcCode(t, err, tc.code)
+				var response *gitalypb.ListTagNamesContainingCommitResponse
+				response, err = stream.Recv()
+				if err != nil {
+					if errors.Is(err, io.EOF) {
+						err = nil
+					}
 
-					return
+					break
 				}
-				require.NoError(t, err)
 
-				for _, name := range r.GetTagNames() {
-					names = append(names, string(name))
+				for _, tagName := range response.GetTagNames() {
+					tagNames = append(tagNames, string(tagName))
 				}
 			}
 
-			// Test for inclusion instead of equality because new refs
-			// will get added to the gitlab-test repo over time.
-			require.Subset(t, names, tc.tags)
-		})
-	}
-}
-
-func TestListTagNamesContainingCommit_validate(t *testing.T) {
-	t.Parallel()
-	ctx := testhelper.Context(t)
-	_, repoProto, _, client := setupRefService(t, ctx)
-
-	for _, tc := range []struct {
-		desc        string
-		req         *gitalypb.ListTagNamesContainingCommitRequest
-		expectedErr error
-	}{
-		{
-			desc: "repository not provided",
-			req:  &gitalypb.ListTagNamesContainingCommitRequest{Repository: nil},
-			expectedErr: status.Error(codes.InvalidArgument, testhelper.GitalyOrPraefect(
-				"empty Repository",
-				"repo scoped: empty Repository",
-			)),
-		},
-		{
-			desc:        "bad commit provided",
-			req:         &gitalypb.ListTagNamesContainingCommitRequest{Repository: repoProto, CommitId: "invalid"},
-			expectedErr: status.Error(codes.InvalidArgument, fmt.Sprintf(`invalid object ID: "invalid", expected length %v, got 7`, gittest.DefaultObjectHash.EncodedLen())),
-		},
-	} {
-		t.Run(tc.desc, func(t *testing.T) {
-			stream, err := client.ListTagNamesContainingCommit(ctx, tc.req)
-			require.NoError(t, err)
-			_, err = stream.Recv()
 			testhelper.RequireGrpcError(t, tc.expectedErr, err)
+			require.ElementsMatch(t, tc.expectedTags, tagNames)
 		})
 	}
 }