Skip to content

Git designed for AI agents.

10.5 KB
Raw Blame
package resolver

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/feder-cr/git-ai/internal/gitaly/config"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/stretchr/testify/require"
)

// writeToken writes a token file and returns its path.
func writeToken(t *testing.T, token string) string {
	t.Helper()

	path := filepath.Join(t.TempDir(), "token")
	require.NoError(t, os.WriteFile(path, []byte(token+"\n"), 0o600))
	return path
}

// httpConfig returns an enabled URL resolver configuration.
func httpConfig(url, tokenFile string) config.GraftResolver {
	return config.GraftResolver{Enabled: true, URL: url, TokenFile: tokenFile, Timeout: "10s"}
}

// answeringHandler checks the protocol shape of a request and answers
// validResponse. Failures are reported with t.Errorf, which is safe to call
// from the handler goroutine.
func answeringHandler(t *testing.T, wantAuth string, hits *atomic.Int32) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		hits.Add(1)

		if r.Method != http.MethodPost {
			t.Errorf("method %s, want POST", r.Method)
			w.WriteHeader(http.StatusMethodNotAllowed)
			return
		}

		if got := r.Header.Get("Content-Type"); got != "application/json" {
			t.Errorf("Content-Type %q", got)
		}

		if got := r.Header.Get("Accept"); got != "application/json" {
			t.Errorf("Accept %q", got)
		}

		if got := r.Header.Get("Authorization"); got != wantAuth {
			w.WriteHeader(http.StatusUnauthorized)
			return
		}

		var req Request
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			t.Errorf("decode request: %v", err)
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		if req.Version != ProtocolVersion || len(req.Files) != 2 {
			t.Errorf("unexpected request: version %d, %d files", req.Version, len(req.Files))
		}

		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(validResponse("merged\n"))
	}
}

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

	var hits atomic.Int32
	srv := httptest.NewServer(answeringHandler(t, "Bearer s3cret", &hits))
	t.Cleanup(srv.Close)

	client := newClient(t, httpConfig(srv.URL, writeToken(t, "s3cret")))

	resp, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.NoError(t, err)
	require.Equal(t, []byte("merged\n"), resp.Files[0].Content)
	require.Equal(t, "graft-resolve/test", resp.Resolver)
	require.Equal(t, int32(1), hits.Load())
}

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

	var hits atomic.Int32
	srv := httptest.NewServer(answeringHandler(t, "", &hits))
	t.Cleanup(srv.Close)

	client := newClient(t, httpConfig(srv.URL, ""))

	_, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.NoError(t, err)
}

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

	var hits atomic.Int32
	srv := httptest.NewServer(answeringHandler(t, "Bearer first", &hits))
	t.Cleanup(srv.Close)

	tokenFile := writeToken(t, "first")
	client := newClient(t, httpConfig(srv.URL, tokenFile))

	// Rotating the file afterwards does not change what the client sends.
	require.NoError(t, os.WriteFile(tokenFile, []byte("second\n"), 0o600))

	_, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.NoError(t, err)
}

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

	for _, tc := range []struct {
		name       string
		body       string
		wantReason string
	}{
		{name: "error member", body: `{"error":"ambiguous rename"}`, wantReason: "ambiguous rename"},
		{name: "error member is trimmed", body: `{"error":"  padded  "}`, wantReason: "padded"},
		{name: "empty error member", body: `{"error":""}`, wantReason: defaultRefusalReason},
		{name: "plain text body", body: `binary conflict`, wantReason: defaultRefusalReason},
		{name: "empty body", body: ``, wantReason: defaultRefusalReason},
	} {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
				w.WriteHeader(http.StatusUnprocessableEntity)
				_, _ = w.Write([]byte(tc.body))
			}))
			t.Cleanup(srv.Close)

			client := newClient(t, httpConfig(srv.URL, ""))

			resp, err := client.resolve(testhelper.Context(t), sampleRequest())
			require.Nil(t, resp)
			require.ErrorIs(t, err, ErrUnresolvable)
			require.False(t, errors.Is(err, ErrInvalidResponse))

			var unresolvable *UnresolvableError
			require.ErrorAs(t, err, &unresolvable)
			require.Equal(t, tc.wantReason, unresolvable.Reason)
		})
	}
}

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

	for _, status := range []int{http.StatusInternalServerError, http.StatusBadRequest, http.StatusTooManyRequests, http.StatusNoContent} {
		t.Run(http.StatusText(status), func(t *testing.T) {
			t.Parallel()

			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
				w.WriteHeader(status)
				_, _ = w.Write([]byte(`{"version":1,"files":[]}`))
			}))
			t.Cleanup(srv.Close)

			client := newClient(t, httpConfig(srv.URL, ""))

			resp, err := client.resolve(testhelper.Context(t), sampleRequest())
			require.Nil(t, resp)
			require.Error(t, err)
			require.False(t, errors.Is(err, ErrUnresolvable), "only HTTP 422 is a refusal")
		})
	}
}

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

	var target atomic.Int32
	dest := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		target.Add(1)
		w.WriteHeader(http.StatusOK)
	}))
	t.Cleanup(dest.Close)

	redirect := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, dest.URL, http.StatusFound)
	}))
	t.Cleanup(redirect.Close)

	client := newClient(t, httpConfig(redirect.URL, writeToken(t, "s3cret")))

	_, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.Error(t, err)
	require.False(t, errors.Is(err, ErrUnresolvable))
	require.Equal(t, int32(0), target.Load(), "the bearer token must not follow a redirect")
}

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

	markerResp := validResponse("<<<<<<< ours\nx\n=======\ny\n>>>>>>> theirs\n")

	for _, tc := range []struct {
		name string
		body string
	}{
		{name: "not JSON", body: "merged"},
		{name: "wrong version", body: `{"version":3,"files":[]}`},
		{name: "conflict marker", body: string(mustJSON(t, markerResp))},
		{name: "unanswered conflict", body: `{"version":1,"files":[]}`},
	} {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
				_, _ = w.Write([]byte(tc.body))
			}))
			t.Cleanup(srv.Close)

			client := newClient(t, httpConfig(srv.URL, ""))

			resp, err := client.resolve(testhelper.Context(t), sampleRequest())
			require.Nil(t, resp)
			require.ErrorIs(t, err, ErrInvalidResponse)
			require.False(t, errors.Is(err, ErrUnresolvable))
		})
	}
}

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

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		// Far beyond the bound for two 1 KiB files.
		_, _ = w.Write([]byte(strings.Repeat(" ", 300_000)))
	}))
	t.Cleanup(srv.Close)

	cfg := httpConfig(srv.URL, "")
	cfg.MaxFileBytes = 1024
	client := newClient(t, cfg)

	resp, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.Nil(t, resp)
	require.ErrorIs(t, err, ErrInvalidResponse)
	require.ErrorContains(t, err, "exceeds")
}

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

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		select {
		case <-r.Context().Done():
		case <-time.After(10 * time.Second):
		}
	}))
	t.Cleanup(srv.Close)

	cfg := httpConfig(srv.URL, "")
	cfg.Timeout = "200ms"
	client := newClient(t, cfg)

	start := time.Now()
	resp, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.Nil(t, resp)
	require.ErrorIs(t, err, context.DeadlineExceeded)
	require.False(t, errors.Is(err, ErrUnresolvable))
	require.Less(t, time.Since(start), 8*time.Second)
}

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

	srv := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
	url := srv.URL
	srv.Close()

	client := newClient(t, httpConfig(url, ""))

	resp, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.Nil(t, resp)
	require.Error(t, err)
	require.False(t, errors.Is(err, ErrUnresolvable))
}

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

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	t.Cleanup(srv.Close)

	client := newClient(t, httpConfig(srv.URL, writeToken(t, "s3cret-token-value")))

	_, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.Error(t, err)
	require.NotContains(t, err.Error(), "s3cret-token-value")
}

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

	var hits atomic.Int32
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		hits.Add(1)
	}))
	t.Cleanup(srv.Close)

	cfg := httpConfig(srv.URL, "")
	cfg.PathsDeny = []string{"a.*"}
	client := newClient(t, cfg)

	_, err := client.resolve(testhelper.Context(t), sampleRequest())
	require.ErrorContains(t, err, "is not allowed to be resolved")
	require.Equal(t, int32(0), hits.Load())
}

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

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		select {
		case <-r.Context().Done():
		case <-time.After(10 * time.Second):
		}
	}))
	t.Cleanup(srv.Close)

	client := newClient(t, httpConfig(srv.URL, ""))

	ctx, cancel := context.WithCancel(testhelper.Context(t))
	time.AfterFunc(100*time.Millisecond, cancel)

	_, err := client.resolve(ctx, sampleRequest())
	require.ErrorIs(t, err, context.Canceled)
}

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

	var hits atomic.Int32
	srv := httptest.NewServer(answeringHandler(t, "Bearer s3cret", &hits))
	t.Cleanup(srv.Close)

	client := newClient(t, httpConfig(srv.URL, writeToken(t, "s3cret")))

	const workers = 16
	var wg sync.WaitGroup
	errs := make(chan error, workers)
	for i := 0; i < workers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()

			_, err := client.resolve(context.Background(), sampleRequest())
			errs <- err
		}()
	}

	wg.Wait()
	close(errs)
	for err := range errs {
		require.NoError(t, err)
	}
	require.Equal(t, int32(workers), hits.Load())
}