Skip to content

Git designed for AI agents.

16.2 KB
Raw Blame
package sdk_test

import (
	"fmt"
	"sync"
	"testing"

	"github.com/stretchr/testify/require"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/proto/go/gitalypb"
	"github.com/feder-cr/git-ai/sdk"
)

// reviewBaseSource is the base version of the Go file that the review tests change.
const reviewBaseSource = "package x\n\nfunc F() {}\n"

// reviewCodeSource is a change of the code of reviewBaseSource.
const reviewCodeSource = "package x\n\nfunc F() int { return 1 }\n"

// reviewCommentSource adds a comment to reviewCodeSource only.
const reviewCommentSource = "package x\n\n// F returns one.\nfunc F() int { return 1 }\n"

// allowSelfApproval configures one rule that requires one approval of code
// changes and lets the author approve. The tests run without an identity, so
// every change and every verdict comes from the same anonymous actor.
func allowSelfApproval(cfg *config.Cfg) {
	cfg.Graft.Review = config.GraftReview{Rules: []config.GraftReviewRule{
		{Name: "code", Classes: []string{"code"}, Approvals: 1, AllowAuthor: true},
	}}
}

// createTestReview opens a review of head against branch.
func createTestReview(t *testing.T, env integrationEnv, branch, head string) *sdk.Review {
	t.Helper()

	review, err := env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{
		TargetBranch: branch,
		Head:         head,
		Title:        "change " + head[:8],
	})
	require.NoError(t, err)
	return review
}

func TestIntegration_CreateReview(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)

	t.Run("defaults the base to the merge base and classifies the files", func(t *testing.T) {
		review, err := env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{
			TargetBranch: "refs/heads/main",
			Head:         head.String(),
			Title:        "fix x",
			Description:  "details",
		})
		require.NoError(t, err)

		require.NotEmpty(t, review.GetId())
		require.Equal(t, "main", string(review.GetTargetBranch()), "the refs/heads/ prefix is not stored")
		require.Equal(t, base.String(), review.GetBaseCommitId())
		require.Equal(t, head.String(), review.GetHeadCommitId())
		require.Equal(t, sdk.ReviewOpen, review.GetState())
		require.Equal(t, "fix x", string(review.GetTitle()))
		require.Equal(t, "details", string(review.GetDescription()))
		require.Equal(t, "anonymous", review.GetAuthor())

		require.Len(t, review.GetFiles(), 1)
		require.Equal(t, "x.go", string(review.GetFiles()[0].GetPath()))
		require.Equal(t, gitalypb.ReviewFile_CHANGE_CLASS_CODE_UNSPECIFIED, review.GetFiles()[0].GetClass())

		require.Len(t, review.GetRequirements(), 1)
		require.Equal(t, int32(1), review.GetRequirements()[0].GetRequiredApprovals())
		require.False(t, review.GetRequirements()[0].GetSatisfied())
		require.False(t, review.GetApproved())
	})

	t.Run("uses the given base", func(t *testing.T) {
		review, err := env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{
			TargetBranch: "main",
			Head:         head.String(),
			Base:         base.String(),
		})
		require.NoError(t, err)
		require.Equal(t, base.String(), review.GetBaseCommitId())
	})

	t.Run("validates the arguments", func(t *testing.T) {
		_, err := env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{Head: head.String()})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "missing branch")

		_, err = env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{TargetBranch: "main"})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "missing head")

		_, err = env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{TargetBranch: "bad..name", Head: head.String()})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "invalid branch name")
	})

	t.Run("unknown branch and head are not found", func(t *testing.T) {
		_, err := env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{TargetBranch: "no-such-branch", Head: head.String()})
		require.Equal(t, codes.NotFound, status.Code(err), "branch: %v", err)

		_, err = env.repo.CreateReview(env.ctx, sdk.CreateReviewOptions{TargetBranch: "main", Head: "no-such-rev"})
		require.Equal(t, codes.NotFound, status.Code(err), "head: %v", err)
	})
}

func TestIntegration_GetReview(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	created := createTestReview(t, env, "main", head.String())

	got, err := env.repo.GetReview(env.ctx, created.GetId())
	require.NoError(t, err)
	require.Equal(t, created.GetId(), got.GetId())
	require.Equal(t, created.GetTitle(), got.GetTitle())
	require.Equal(t, head.String(), got.GetHeadCommitId())

	_, err = env.repo.GetReview(env.ctx, "")
	require.Equal(t, codes.InvalidArgument, status.Code(err))

	_, err = env.repo.GetReview(env.ctx, "999999")
	require.True(t, sdk.IsNotFound(err), "got %v", err)
}

func TestIntegration_ListReviews(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	env.writeCommit(t, "release", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)

	first := createTestReview(t, env, "main", head.String())
	second := createTestReview(t, env, "main", head.String())
	third := createTestReview(t, env, "release", head.String())

	_, err := env.repo.CloseReview(env.ctx, first.GetId(), false)
	require.NoError(t, err)

	t.Run("open reviews, newest first", func(t *testing.T) {
		reviews, err := env.repo.ListReviews(env.ctx, sdk.ListReviewsOptions{})
		require.NoError(t, err)
		require.Len(t, reviews, 2, "the closed review is hidden")
		require.Equal(t, third.GetId(), reviews[0].GetId())
		require.Equal(t, second.GetId(), reviews[1].GetId())
	})

	t.Run("filters by target branch", func(t *testing.T) {
		reviews, err := env.repo.ListReviews(env.ctx, sdk.ListReviewsOptions{TargetBranch: "refs/heads/main"})
		require.NoError(t, err)
		require.Len(t, reviews, 1)
		require.Equal(t, second.GetId(), reviews[0].GetId())
	})

	t.Run("includes closed reviews", func(t *testing.T) {
		reviews, err := env.repo.ListReviews(env.ctx, sdk.ListReviewsOptions{TargetBranch: "main", IncludeClosed: true})
		require.NoError(t, err)
		require.Len(t, reviews, 2)
		require.Equal(t, second.GetId(), reviews[0].GetId())
		require.Equal(t, first.GetId(), reviews[1].GetId())
	})

	t.Run("limit bounds the listing", func(t *testing.T) {
		reviews, err := env.repo.ListReviews(env.ctx, sdk.ListReviewsOptions{IncludeClosed: true, Limit: 1})
		require.NoError(t, err)
		require.Len(t, reviews, 1)
		require.Equal(t, third.GetId(), reviews[0].GetId())
	})
}

func TestIntegration_UpdateReview(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head1 := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	head2 := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource + "\n"}, head1)
	review := createTestReview(t, env, "main", head1.String())

	t.Run("expected head must match", func(t *testing.T) {
		_, err := env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{
			ID:           review.GetId(),
			Head:         head2.String(),
			ExpectedHead: base.String(),
		})
		require.Equal(t, codes.FailedPrecondition, status.Code(err))

		updated, err := env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{
			ID:           review.GetId(),
			Head:         head2.String(),
			ExpectedHead: head1.String(),
		})
		require.NoError(t, err)
		require.Equal(t, head2.String(), updated.GetHeadCommitId())
	})

	t.Run("validates the arguments", func(t *testing.T) {
		_, err := env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{ID: review.GetId()})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "missing head")

		_, err = env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{Head: head1.String()})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "missing ID")
	})

	t.Run("unknown review is not found", func(t *testing.T) {
		_, err := env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{ID: "999999", Head: head1.String()})
		require.True(t, sdk.IsNotFound(err), "got %v", err)
	})
}

func TestIntegration_CommentReview(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	review := createTestReview(t, env, "main", head.String())

	comment, err := env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{
		ID:   review.GetId(),
		Body: "nit",
		Path: "x.go",
		Line: 3,
	})
	require.NoError(t, err)
	require.Equal(t, "nit", string(comment.GetBody()))
	require.Equal(t, "x.go", string(comment.GetPath()))
	require.Equal(t, int32(3), comment.GetLine())
	require.Equal(t, head.String(), comment.GetCommitId())

	t.Run("validates the arguments", func(t *testing.T) {
		_, err := env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{ID: review.GetId()})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "empty body")

		_, err = env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{ID: review.GetId(), Body: "x", Line: -1})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "negative line")

		_, err = env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{Body: "x"})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "missing ID")
	})

	t.Run("path must be a file of the review", func(t *testing.T) {
		_, err := env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{ID: review.GetId(), Body: "x", Path: "other.go"})
		require.Equal(t, codes.InvalidArgument, status.Code(err), "got %v", err)
	})

	t.Run("unknown review is not found", func(t *testing.T) {
		_, err := env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{ID: "999999", Body: "x"})
		require.True(t, sdk.IsNotFound(err), "got %v", err)
	})

	t.Run("comments are stored in order", func(t *testing.T) {
		got, err := env.repo.GetReview(env.ctx, review.GetId())
		require.NoError(t, err)
		require.Len(t, got.GetComments(), 1, "refused comments are not stored")
		require.Equal(t, "nit", string(got.GetComments()[0].GetBody()))
	})
}

func TestIntegration_CommentReviewConcurrently(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	review := createTestReview(t, env, "main", head.String())

	const n = 20
	ids := make([]string, n)
	errs := make([]error, n)
	var wg sync.WaitGroup
	for i := range n {
		wg.Add(1)
		go func() {
			defer wg.Done()
			comment, err := env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{
				ID:   review.GetId(),
				Body: fmt.Sprintf("comment %d", i),
			})
			errs[i] = err
			if comment != nil {
				ids[i] = comment.GetId()
			}
		}()
	}
	wg.Wait()

	seen := map[string]bool{}
	for i := range n {
		require.NoError(t, errs[i])
		require.False(t, seen[ids[i]], "comment ID %q is not unique", ids[i])
		seen[ids[i]] = true
	}

	got, err := env.repo.GetReview(env.ctx, review.GetId())
	require.NoError(t, err)
	require.Len(t, got.GetComments(), n)
}

func TestIntegration_ApproveAndRequestChanges(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, allowSelfApproval)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	review := createTestReview(t, env, "main", head.String())
	require.False(t, review.GetApproved())

	approved, err := env.repo.ApproveReview(env.ctx, review.GetId(), "lgtm")
	require.NoError(t, err)
	require.Len(t, approved.GetVerdicts(), 1)
	verdict := approved.GetVerdicts()[0]
	require.Equal(t, gitalypb.ReviewVerdict_KIND_APPROVE_UNSPECIFIED, verdict.GetKind())
	require.Equal(t, head.String(), verdict.GetCommitId(), "the verdict names the head it was given on")
	require.True(t, verdict.GetCurrent())
	require.True(t, approved.GetApproved())

	changed, err := env.repo.RequestChanges(env.ctx, review.GetId(), "wait")
	require.NoError(t, err)
	require.Len(t, changed.GetVerdicts(), 2)
	require.Equal(t, gitalypb.ReviewVerdict_KIND_REQUEST_CHANGES, changed.GetVerdicts()[1].GetKind())
	require.False(t, changed.GetApproved(), "a change request blocks approval")

	reapproved, err := env.repo.ApproveReview(env.ctx, review.GetId(), "")
	require.NoError(t, err)
	require.True(t, reapproved.GetApproved(), "a later approval by the same actor supersedes the request")

	t.Run("unknown review is not found", func(t *testing.T) {
		_, err := env.repo.ApproveReview(env.ctx, "999999", "")
		require.True(t, sdk.IsNotFound(err), "got %v", err)
	})
}

func TestIntegration_AuthorApprovalDoesNotCountByDefault(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	review := createTestReview(t, env, "main", head.String())

	got, err := env.repo.ApproveReview(env.ctx, review.GetId(), "")
	require.NoError(t, err)
	require.False(t, got.GetApproved(), "the author cannot approve their own change under the default rules")
	require.Len(t, got.GetRequirements(), 1)
	require.Equal(t, int32(0), got.GetRequirements()[0].GetApprovals())
}

func TestIntegration_UpdateKeepsApprovalsForCommentOnlyChanges(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, allowSelfApproval)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head1 := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)
	commentOnly := env.writeCommit(t, "", map[string]string{"x.go": reviewCommentSource}, head1)
	codeChange := env.writeCommit(t, "", map[string]string{"x.go": "package x\n\nfunc F() int { return 2 }\n"}, commentOnly)

	review := createTestReview(t, env, "main", head1.String())
	_, err := env.repo.ApproveReview(env.ctx, review.GetId(), "")
	require.NoError(t, err)

	kept, err := env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{ID: review.GetId(), Head: commentOnly.String()})
	require.NoError(t, err)
	require.True(t, kept.GetApproved(), "a comment-only change keeps the approval")
	require.True(t, kept.GetVerdicts()[0].GetCurrent())

	dropped, err := env.repo.UpdateReview(env.ctx, sdk.UpdateReviewOptions{ID: review.GetId(), Head: codeChange.String()})
	require.NoError(t, err)
	require.False(t, dropped.GetApproved(), "a code change needs a new approval")
	require.False(t, dropped.GetVerdicts()[0].GetCurrent())
}

func TestIntegration_CloseReview(t *testing.T) {
	t.Parallel()

	env := startIntegration(t, nil)
	base := env.writeCommit(t, "main", map[string]string{"x.go": reviewBaseSource})
	head := env.writeCommit(t, "", map[string]string{"x.go": reviewCodeSource}, base)

	landed := createTestReview(t, env, "main", head.String())
	closed, err := env.repo.CloseReview(env.ctx, landed.GetId(), true)
	require.NoError(t, err)
	require.Equal(t, sdk.ReviewLanded, closed.GetState())

	abandoned := createTestReview(t, env, "main", head.String())
	closed, err = env.repo.CloseReview(env.ctx, abandoned.GetId(), false)
	require.NoError(t, err)
	require.Equal(t, sdk.ReviewClosed, closed.GetState())

	t.Run("closed reviews accept no changes", func(t *testing.T) {
		_, err := env.repo.CommentReview(env.ctx, sdk.CommentReviewOptions{ID: landed.GetId(), Body: "late"})
		require.Equal(t, codes.FailedPrecondition, status.Code(err), "comment: %v", err)

		_, err = env.repo.ApproveReview(env.ctx, abandoned.GetId(), "")
		require.Equal(t, codes.FailedPrecondition, status.Code(err), "approve: %v", err)

		_, err = env.repo.CloseReview(env.ctx, abandoned.GetId(), true)
		require.Equal(t, codes.FailedPrecondition, status.Code(err), "close again: %v", err)
	})

	t.Run("validates the ID and reports unknown reviews", func(t *testing.T) {
		_, err := env.repo.CloseReview(env.ctx, "", false)
		require.Equal(t, codes.InvalidArgument, status.Code(err))

		_, err = env.repo.CloseReview(env.ctx, "999999", false)
		require.True(t, sdk.IsNotFound(err), "got %v", err)
	})
}