package githttp

import ( "bytes" "compress/gzip" "errors" "fmt" "io" "net/http" "net/http/httptest" "strings" "testing"

"github.com/go-git/go-git/v5/storage/memory"

)

func TestInfoRefsBanner(t *testing.T) { rec := httptest.NewRecorder() if err := InfoRefs(rec, memory.NewStorage(), UploadPack); err != nil { t.Fatalf("InfoRefs: %v", err) } body := rec.Body.String() // pkt-line: 4-hex length ("001e") + "# service=git-upload-pack\n", then a // flush-pkt "0000". const want = "001e# service=git-upload-pack\n0000" if !strings.HasPrefix(body, want) { t.Fatalf("advertisement prefix = %q, want prefix %q", body[:min(len(body), 40)], want) } if ct := rec.Header().Get("Content-Type"); ct != "application/x-git-upload-pack-advertisement" { t.Errorf("Content-Type = %q", ct) } if cc := rec.Header().Get("Cache-Control"); cc != "no-cache" { t.Errorf("Cache-Control = %q", cc) } }

func TestInfoRefsReceivePackCapabilities(t *testing.T) { rec := httptest.NewRecorder() if err := InfoRefs(rec, memory.NewStorage(), ReceivePack); err != nil { t.Fatalf("InfoRefs: %v", err) } body := rec.Body.String() if !strings.HasPrefix(body, "001f# service=git-receive-pack\n0000") { t.Fatalf("receive-pack banner wrong: %q", body[:min(len(body), 40)]) } // The advertisement must offer the capabilities stock git needs to push and // delete branches, and to receive a status report. for _, cap := range []string{"report-status", "delete-refs"} { if !strings.Contains(body, cap) { t.Errorf("advertisement missing capability %q", cap) } } }

func TestRequestBodyGzip(t *testing.T) { var gz bytes.Buffer zw := gzip.NewWriter(&gz) const payload = "0009done\n" if _, err := zw.Write([]byte(payload)); err != nil { t.Fatal(err) } zw.Close()

r := httptest.NewRequest("POST", "/x/git-upload-pack", bytes.NewReader(gz.Bytes()))
r.Header.Set("Content-Encoding", "gzip")

body, err := requestBody(r)
if err != nil {
	t.Fatalf("requestBody: %v", err)
}
defer body.Close()
got, err := io.ReadAll(body)
if err != nil {
	t.Fatalf("read: %v", err)
}
if string(got) != payload {
	t.Fatalf("gunzipped body = %q, want %q", got, payload)
}

}

// receivePackBody is a minimal create-branch request followed by payload. func receivePackBody(payload []byte) []byte { const ( oldOID = "0000000000000000000000000000000000000000" newOID = "1111111111111111111111111111111111111111" ) cmd := fmt.Sprintf("%s %s refs/heads/master\x00report-status\n", oldOID, newOID) var body bytes.Buffer fmt.Fprintf(&body, "%04x%s", len(cmd)+4, cmd) body.WriteString("0000") body.Write(payload) return body.Bytes() }

func TestDecodeReceivePackProbe(t *testing.T) { r := httptest.NewRequest("POST", "/git-receive-pack", strings.NewReader("0000")) if _, err := DecodeReceivePack(r); !errors.Is(err, ErrProbe) { t.Fatalf("probe: err = %v, want ErrProbe", err) }

// A real request still decodes, with its first pkt-line intact after the
// 4-byte peek.
r = httptest.NewRequest("POST", "/git-receive-pack", bytes.NewReader(receivePackBody([]byte("PACKDATA"))))
req, err := DecodeReceivePack(r)
if err != nil {
	t.Fatalf("real request: %v", err)
}
if len(req.Commands) != 1 || req.Commands[0].Name != "refs/heads/master" {
	t.Fatalf("commands = %+v", req.Commands)
}
rest, _ := io.ReadAll(req.Packfile)
if string(rest) != "PACKDATA" {
	t.Errorf("pack stream = %q", rest)
}

// Empty and truncated bodies are errors, not probes.
for _, body := range []string{"", "00"} {
	r = httptest.NewRequest("POST", "/git-receive-pack", strings.NewReader(body))
	if _, err := DecodeReceivePack(r); err == nil || errors.Is(err, ErrProbe) {
		t.Errorf("body %q: err = %v", body, err)
	}
}

}

func TestDecodeReceivePackProbeGzip(t *testing.T) { var gz bytes.Buffer zw := gzip.NewWriter(&gz) zw.Write([]byte("0000")) zw.Close() r := httptest.NewRequest("POST", "/git-receive-pack", &gz) r.Header.Set("Content-Encoding", "gzip") if _, err := DecodeReceivePack(r); !errors.Is(err, ErrProbe) { t.Fatalf("gzipped probe: err = %v, want ErrProbe", err) } }

// TestDecodeReceivePackChunked drives a chunked body through a real // http.Server, which is what git sends once a request exceeds // http.postBuffer (default 1 MiB). Kept from docs/FR-large-push-400.md. func TestDecodeReceivePackChunked(t *testing.T) { var pack bytes.Buffer pack.WriteString("PACK") pack.Write([]byte{0, 0, 0, 2, 0, 0, 0, 0}) pack.Write(bytes.Repeat([]byte{0xAB}, 6<<20)) // past postBuffer pack.Write(make([]byte, 20)) body := receivePackBody(pack.Bytes())

errCh := make(chan error, 1)
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	if r.ContentLength != -1 {
		t.Errorf("ContentLength = %d, want -1 (chunked)", r.ContentLength)
	}
	req, err := DecodeReceivePack(r)
	if err == nil && req.Packfile != nil {
		_, err = io.Copy(io.Discard, req.Packfile)
	}
	errCh <- err
}))
defer srv.Close()

hreq, _ := http.NewRequest(http.MethodPost, srv.URL+"/git-receive-pack", io.NopCloser(bytes.NewReader(body)))
hreq.ContentLength = -1 // force chunked
resp, err := http.DefaultClient.Do(hreq)
if err != nil {
	t.Fatalf("request failed: %v", err)
}
resp.Body.Close()
if err := <-errCh; err != nil {
	t.Fatalf("chunked body rejected: %v", err)
}

}