Skip to content

Git designed for AI agents.

9.3 KB
Raw Blame
package sdk_test

import (
	"testing"
	"time"

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

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

func validLand() sdk.LandOptions {
	return sdk.LandOptions{
		Branch: "refs/heads/main",
		Commit: "change-sha",
		User:   sdk.User{ID: "user-1", Name: "Ada", Email: "[email protected]"},
	}
}

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

	fakes := newFakeServices()
	fakes.operations.landResponse = &gitalypb.UserLandResponse{
		BranchUpdate:   &gitalypb.OperationBranchUpdate{CommitId: "landed-sha", BranchCreated: false},
		LandedCommitId: "landed-sha",
		Rewritten:      true,
		Attempts:       3,
		OldTip:         "old-tip-sha",
	}
	repo := dialFake(t, fakes.register).Repo("repo")

	opts := validLand()
	opts.Strategy = sdk.LandMerge
	opts.MaxAttempts = 7
	opts.CreateBranch = true
	opts.MergeMessage = "merge it"
	opts.Timestamp = time.Unix(1700000000, 0)

	result, err := repo.Land(t.Context(), opts)
	require.NoError(t, err)
	require.Equal(t, &sdk.LandResult{
		LandedCommitID: "landed-sha",
		OldTip:         "old-tip-sha",
		Rewritten:      true,
		Attempts:       3,
	}, result)

	require.Len(t, fakes.operations.landRequests, 1)
	req := fakes.operations.landRequests[0]
	require.Equal(t, []byte("main"), req.GetBranch())
	require.Equal(t, "change-sha", req.GetCommitId())
	require.Equal(t, gitalypb.UserLandRequest_STRATEGY_MERGE, req.GetStrategy())
	require.Equal(t, int32(7), req.GetMaxAttempts())
	require.True(t, req.GetCreateBranch())
	require.Equal(t, []byte("merge it"), req.GetMergeMessage())
	require.Equal(t, int64(1700000000), req.GetTimestamp().GetSeconds())
	require.Equal(t, "user-1", req.GetUser().GetGlId())
	require.Equal(t, "default", req.GetRepository().GetStorageName())
}

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

	fakes := newFakeServices()
	fakes.operations.landResponse = &gitalypb.UserLandResponse{
		LandedCommitId: "tip-sha",
		AlreadyLanded:  true,
		OldTip:         "tip-sha",
	}
	repo := dialFake(t, fakes.register).Repo("repo")

	result, err := repo.Land(t.Context(), validLand())
	require.NoError(t, err)
	require.True(t, result.AlreadyLanded)
	require.False(t, result.Rewritten)
	require.Equal(t, "tip-sha", result.LandedCommitID)
}

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

	fakes := newFakeServices()
	fakes.operations.landResponse = &gitalypb.UserLandResponse{
		BranchUpdate:   &gitalypb.OperationBranchUpdate{CommitId: "change-sha", BranchCreated: true},
		LandedCommitId: "change-sha",
	}
	repo := dialFake(t, fakes.register).Repo("repo")

	result, err := repo.Land(t.Context(), validLand())
	require.NoError(t, err)
	require.True(t, result.BranchCreated)
}

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

	fakes := newFakeServices()
	fakes.operations.landResponse = &gitalypb.UserLandResponse{}
	repo := dialFake(t, fakes.register).Repo("repo")

	_, err := repo.Land(t.Context(), validLand())
	require.NoError(t, err)
	require.Equal(t, gitalypb.UserLandRequest_STRATEGY_REBASE_UNSPECIFIED, fakes.operations.landRequests[0].GetStrategy())
}

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

	st, err := status.New(codes.FailedPrecondition, "merge conflict").WithDetails(&gitalypb.UserLandError{
		Error: &gitalypb.UserLandError_MergeConflict{
			MergeConflict: &gitalypb.MergeConflictError{
				ConflictingFiles: [][]byte{[]byte("a.txt")},
			},
		},
	})
	require.NoError(t, err)

	fakes := newFakeServices()
	fakes.operations.landErr = st.Err()
	repo := dialFake(t, fakes.register).Repo("repo")

	_, err = repo.Land(t.Context(), validLand())
	require.Equal(t, codes.FailedPrecondition, sdk.Code(err))
	require.True(t, sdk.IsMergeConflict(err))
	require.False(t, sdk.IsNotAncestor(err))
	require.False(t, sdk.IsRejectedByHook(err))

	landErr, ok := sdk.LandError(err)
	require.True(t, ok)
	require.Equal(t, [][]byte{[]byte("a.txt")}, landErr.GetMergeConflict().GetConflictingFiles())
}

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

	tests := []struct {
		name   string
		detail *gitalypb.UserLandError
		check  func(error) bool
	}{
		{
			name: "not ancestor",
			detail: &gitalypb.UserLandError{Error: &gitalypb.UserLandError_NotAncestor{
				NotAncestor: &gitalypb.NotAncestorError{},
			}},
			check: sdk.IsNotAncestor,
		},
		{
			name: "reference update exhausted",
			detail: &gitalypb.UserLandError{Error: &gitalypb.UserLandError_ReferenceUpdate{
				ReferenceUpdate: &gitalypb.ReferenceUpdateError{ReferenceName: []byte("refs/heads/main")},
			}},
			check: sdk.IsReferenceUpdateConflict,
		},
		{
			name: "custom hook",
			detail: &gitalypb.UserLandError{Error: &gitalypb.UserLandError_CustomHook{
				CustomHook: &gitalypb.CustomHookError{},
			}},
			check: sdk.IsRejectedByHook,
		},
		{
			name: "access check",
			detail: &gitalypb.UserLandError{Error: &gitalypb.UserLandError_AccessCheck{
				AccessCheck: &gitalypb.AccessCheckError{ErrorMessage: "denied"},
			}},
			check: sdk.IsRejectedByHook,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			st, err := status.New(codes.FailedPrecondition, tc.name).WithDetails(tc.detail)
			require.NoError(t, err)

			fakes := newFakeServices()
			fakes.operations.landErr = st.Err()
			repo := dialFake(t, fakes.register).Repo("repo")

			_, err = repo.Land(t.Context(), validLand())
			require.True(t, tc.check(err))
		})
	}
}

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

	t.Run("sends the option and maps the resolution", func(t *testing.T) {
		t.Parallel()

		fakes := newFakeServices()
		fakes.operations.landResponse = &gitalypb.UserLandResponse{
			LandedCommitId: "merge-sha",
			Rewritten:      true,
			OldTip:         "old-tip-sha",
			Attempts:       1,
			ResolvedPaths:  [][]byte{[]byte("a.go"), []byte("docs/b.md")},
			Resolver:       "graft-resolve/union",
		}
		repo := dialFake(t, fakes.register).Repo("repo")

		opts := validLand()
		opts.ResolveConflicts = true
		result, err := repo.Land(t.Context(), opts)
		require.NoError(t, err)
		require.Equal(t, []string{"a.go", "docs/b.md"}, result.ResolvedPaths)
		require.Equal(t, "graft-resolve/union", result.Resolver)
		require.Equal(t, "merge-sha", result.LandedCommitID)

		require.Len(t, fakes.operations.landRequests, 1)
		require.True(t, fakes.operations.landRequests[0].GetResolveConflicts())
	})

	t.Run("is off by default and reports no resolution", func(t *testing.T) {
		t.Parallel()

		fakes := newFakeServices()
		fakes.operations.landResponse = &gitalypb.UserLandResponse{LandedCommitId: "landed-sha"}
		repo := dialFake(t, fakes.register).Repo("repo")

		result, err := repo.Land(t.Context(), validLand())
		require.NoError(t, err)
		require.Empty(t, result.ResolvedPaths)
		require.Empty(t, result.Resolver)

		require.Len(t, fakes.operations.landRequests, 1)
		require.False(t, fakes.operations.landRequests[0].GetResolveConflicts())
	})
}

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

	repo := dialFake(t, newFakeServices().register).Repo("repo")

	tests := []struct {
		name   string
		modify func(*sdk.LandOptions)
	}{
		{name: "missing branch", modify: func(o *sdk.LandOptions) { o.Branch = "" }},
		{name: "missing commit", modify: func(o *sdk.LandOptions) { o.Commit = "" }},
		{name: "negative attempts", modify: func(o *sdk.LandOptions) { o.MaxAttempts = -1 }},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			opts := validLand()
			tc.modify(&opts)

			_, err := repo.Land(t.Context(), opts)
			require.Equal(t, codes.InvalidArgument, sdk.Code(err))
		})
	}
}

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

	fakes := newFakeServices()
	fakes.operations.landResponse = &gitalypb.UserLandResponse{LandedCommitId: "merged", Rewritten: true}
	repo := dialFake(t, fakes.register).Repo("repo")

	opts := validLand()
	opts.Resolution = &sdk.Resolution{Tip: "tip-sha", Commit: "change-sha", Files: []sdk.ResolvedFile{
		{Path: "a.go", Mode: "100644", Content: []byte("merged\n")},
		{Path: "old.go", Delete: true, Mode: "100644", Content: []byte("ignored")},
	}}
	_, err := repo.Land(t.Context(), opts)
	require.NoError(t, err)

	req := fakes.operations.landRequests[0].GetResolution()
	require.Equal(t, "tip-sha", req.GetTip())
	require.Equal(t, "change-sha", req.GetCommit())
	require.Len(t, req.GetFiles(), 2)
	require.Equal(t, gitalypb.LandResolvedFile_ACTION_WRITE, req.GetFiles()[0].GetAction())
	require.Equal(t, "merged\n", string(req.GetFiles()[0].GetContent()))
	del := req.GetFiles()[1]
	require.Equal(t, gitalypb.LandResolvedFile_ACTION_DELETE, del.GetAction())
	require.Empty(t, del.GetMode(), "a deletion carries no mode")
	require.Nil(t, del.GetContent(), "a deletion carries no content")
}

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

	fakes := newFakeServices()
	repo := dialFake(t, fakes.register).Repo("repo")

	opts := validLand()
	opts.Resolution = &sdk.Resolution{Tip: "t", Commit: "c", Files: []sdk.ResolvedFile{
		{Path: "big.bin", Mode: "100644", Content: make([]byte, sdk.MaxLandRequestBytes)},
	}}
	_, err := repo.Land(t.Context(), opts)
	require.Equal(t, codes.InvalidArgument, status.Code(err))
	require.Contains(t, err.Error(), "4 MiB message limit")
	require.Empty(t, fakes.operations.landRequests, "the request is not sent")
}