Skip to content

Git designed for AI agents.

20.7 KB
Raw Blame
package stats

import (
	"bytes"
	"fmt"
	"io"
	"strings"
	"testing"
	"unicode/utf8"

	"github.com/feder-cr/git-ai/internal/git/gittest"
	"github.com/feder-cr/git-ai/internal/log"
	"github.com/feder-cr/git-ai/internal/testhelper"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/stretchr/testify/require"
)

const (
	oid1 = "78fb81a02b03f0013360292ec5106763af32c287"
	oid2 = "0f6394307cd7d4909be96a0c818d8094a4cb0e5b"
)

func requireParses(t *testing.T, reader io.Reader, expected PackfileNegotiation) {
	actual, err := ParsePackfileNegotiation(reader)
	require.NoError(t, err)
	actual.PayloadSize = 0
	actual.Packets = 0

	require.Equal(t, expected, actual)
}

func TestPackNegoWithInvalidPktline(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineFlush(t, buf)
	// Write string with invalid length
	buf.WriteString("0002xyz")
	gittest.WritePktlineString(t, buf, "done")

	_, err := ParsePackfileNegotiation(buf)
	require.Error(t, err, "invalid pktlines should be rejected")
}

func TestPackNegoWithSingleWant(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants: 1, Caps: []string{"cap"}, WantsSample: []string{oid1},
	})
}

func TestPackNegoWithMissingCaps(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants: 1, WantsSample: []string{oid1},
	})
}

func TestPackNegoWithHave(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "have "+oid2)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants: 1, Haves: 1, Caps: []string{"cap"}, WantsSample: []string{oid1},
	})
}

func TestPackNegoWithMultipleHaveRoundds(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "have "+oid2)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "have "+oid1)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Haves:       2,
		Caps:        []string{"cap"},
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithMultipleWants(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineString(t, buf, "want "+oid2)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants: 2, Caps: []string{"cap"}, WantsSample: []string{oid1, oid2},
	})
}

func TestPackNegoWithMultipleCapLines(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap1")
	gittest.WritePktlineString(t, buf, "want "+oid2+" cap2")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	_, err := ParsePackfileNegotiation(buf)
	require.Error(t, err, "multiple capability announcements should fail to parse")
}

func TestPackNegoWithDeepen(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineString(t, buf, "deepen 1")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Caps:        []string{"cap"},
		Deepen:      "deepen 1",
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithMultipleDeepens(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "deepen 1")
	gittest.WritePktlineString(t, buf, "deepen-not "+oid2)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Caps:        []string{"cap"},
		Deepen:      "deepen-not " + oid2,
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithShallow(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineString(t, buf, "shallow "+oid1)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Caps:        []string{"cap"},
		Shallows:    1,
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithMultipleShallows(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineString(t, buf, "shallow "+oid1)
	gittest.WritePktlineString(t, buf, "shallow "+oid2)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Caps:        []string{"cap"},
		Shallows:    2,
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithFilter(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineString(t, buf, "filter blob:none")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Caps:        []string{"cap"},
		Filter:      "blob:none",
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithMultipleFilters(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineString(t, buf, "filter blob:none")
	gittest.WritePktlineString(t, buf, "filter blob:limit=1m")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       1,
		Caps:        []string{"cap"},
		Filter:      "blob:limit=1m",
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithCommandAndAgent(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineString(t, buf, "agent=git/foobar")
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Command:     "fetch",
		UserAgent:   "git/foobar",
		Wants:       1,
		Caps:        []string{"cap"},
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithAgentCapability(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap agent=git/foobar")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Command:     "fetch",
		UserAgent:   "git/foobar",
		Wants:       1,
		Caps:        []string{"cap", "agent=git/foobar"},
		WantsSample: []string{oid1},
	})
}

func TestPackNegoWithLsRefsPipelineRefPrefixes(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=ls-refs")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "ref-prefix refs/heads/main")
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/123")
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/invalid")
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/12345678901234567890")
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/456")
	gittest.WritePktlineFlush(t, buf)

	actual, err := ParsePackfileNegotiation(buf, WithLsRefsPipelineRefPrefixes())
	require.NoError(t, err)
	actual.PayloadSize = 0
	actual.Packets = 0
	require.Equal(t, PackfileNegotiation{
		Command:             "ls-refs",
		PipelineRefPrefixes: 2,
	}, actual)
}

func TestPackNegoWithLsRefsPipelineRefPrefixesDisabled(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=ls-refs")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/123")
	gittest.WritePktlineFlush(t, buf)

	requireParses(t, buf, PackfileNegotiation{Command: "ls-refs"})
}

func TestPackNegoWithPipelineRefPrefixForNonLsRefsCommand(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/123")
	gittest.WritePktlineFlush(t, buf)

	requireParses(t, buf, PackfileNegotiation{Command: "fetch"})
}

func TestPackNegoWithInvalidRefPrefix(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=ls-refs")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "ref-prefix")
	gittest.WritePktlineString(t, buf, "ref-prefix refs/pipelines/123 extra")
	gittest.WritePktlineFlush(t, buf)

	actual, err := ParsePackfileNegotiation(buf, WithLsRefsPipelineRefPrefixes())
	require.NoError(t, err)
	actual.PayloadSize = 0
	actual.Packets = 0
	require.Equal(t, PackfileNegotiation{Command: "ls-refs"}, actual)
}

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

	for _, tc := range []struct {
		desc            string
		deepen          string
		expectedSamples int
	}{
		{
			desc:            "deepen-since is not observed",
			deepen:          "deepen-since 1234567890",
			expectedSamples: 0,
		},
		{
			desc:            "deepen-not is not observed",
			deepen:          "deepen-not " + oid1,
			expectedSamples: 0,
		},
		{
			desc:            "empty deepen is not observed",
			deepen:          "",
			expectedSamples: 0,
		},
		{
			desc:            "depth 1",
			deepen:          "deepen 1",
			expectedSamples: 1,
		},
		{
			desc:            "depth 10",
			deepen:          "deepen 10",
			expectedSamples: 1,
		},
		{
			desc:            "depth 10000",
			deepen:          "deepen 10000",
			expectedSamples: 1,
		},
		{
			desc:            "sentinel value 0x7fffffff (INFINITE_DEPTH) is observed",
			deepen:          fmt.Sprintf("deepen %d", 0x7fffffff),
			expectedSamples: 1,
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			t.Parallel()

			negotiationMetrics := prometheus.NewCounterVec(prometheus.CounterOpts{}, []string{"git_negotiation_feature"})
			deepenHistogram := prometheus.NewHistogram(prometheus.HistogramOpts{Name: "test_packfile_negotiation_deepen"})
			pn := PackfileNegotiation{Deepen: tc.deepen}
			pn.UpdateMetrics(negotiationMetrics, deepenHistogram)

			testhelper.RequireHistogramSampleCounts(t, deepenHistogram, map[string]int{
				"test_packfile_negotiation_deepen": tc.expectedSamples,
			})
		})
	}
}

func TestPackNegoFullBlown(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1+" cap1 cap2")
	gittest.WritePktlineString(t, buf, "want "+oid2)
	gittest.WritePktlineString(t, buf, "shallow "+oid2)
	gittest.WritePktlineString(t, buf, "shallow "+oid1)
	gittest.WritePktlineString(t, buf, "deepen 1")
	gittest.WritePktlineString(t, buf, "filter blob:none")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "have "+oid2)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "have "+oid1)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       2,
		Haves:       2,
		Caps:        []string{"cap1", "cap2"},
		Shallows:    2,
		Deepen:      "deepen 1",
		Filter:      "blob:none",
		WantsSample: []string{oid1, oid2},
	})
}

func TestPackNegoWantsSampleIsTruncated(t *testing.T) {
	buf := &bytes.Buffer{}

	// Announce more wants than the sample retains, each OID distinct so both the
	// truncation and the ordering are observable.
	var wants []string
	for i := 0; i < maxSampleEntries+5; i++ {
		oid := fmt.Sprintf("%040x", i)
		wants = append(wants, oid)
		gittest.WritePktlineString(t, buf, "want "+oid)
	}
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Wants:       maxSampleEntries + 5,
		WantsSample: wants[:maxSampleEntries],
	})
}

func TestPackNegoWithWantRef(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "want-ref refs/heads/main")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	// A "want-ref" names a ref instead of an object, so it must not be counted as a want nor
	// land in the OID sample.
	requireParses(t, buf, PackfileNegotiation{
		Command:        "fetch",
		WantRefs:       1,
		WantRefsSample: []string{"refs/heads/main"},
	})
}

func TestPackNegoWithMixedWantsAndWantRefs(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "want "+oid1)
	gittest.WritePktlineString(t, buf, "want-ref refs/heads/main")
	gittest.WritePktlineString(t, buf, "want "+oid2)
	gittest.WritePktlineString(t, buf, "want-ref refs/tags/v1.0.0")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	requireParses(t, buf, PackfileNegotiation{
		Command:        "fetch",
		Wants:          2,
		WantsSample:    []string{oid1, oid2},
		WantRefs:       2,
		WantRefsSample: []string{"refs/heads/main", "refs/tags/v1.0.0"},
	})
}

func TestPackNegoWantRefsSampleIsTruncated(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)

	// Announce more want-refs than the sample retains, each ref distinct so both the truncation
	// and the ordering are observable.
	var refs []string
	for i := 0; i < maxSampleEntries+5; i++ {
		ref := fmt.Sprintf("refs/heads/branch-%d", i)
		refs = append(refs, ref)
		gittest.WritePktlineString(t, buf, "want-ref "+ref)
	}
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	// The counter keeps the true number of want-refs, which the capped sample cannot.
	requireParses(t, buf, PackfileNegotiation{
		Command:        "fetch",
		WantRefs:       maxSampleEntries + 5,
		WantRefsSample: refs[:maxSampleEntries],
	})
}

func TestPackNegoWithInvalidWantRef(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "want-ref")
	gittest.WritePktlineString(t, buf, "want-ref refs/heads/main extra")
	gittest.WritePktlineString(t, buf, "want-ref refs/heads/valid")
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	// Malformed want-refs are ignored rather than failing the parse: this is log-only
	// instrumentation, and a parse error drops every other statistic for the request.
	requireParses(t, buf, PackfileNegotiation{
		Command:        "fetch",
		WantRefs:       1,
		WantRefsSample: []string{"refs/heads/valid"},
	})
}

func TestPackNegoWantSampleDropsOverlongValues(t *testing.T) {
	sha256OID := strings.Repeat("a", maxWantLen)
	overlong := strings.Repeat("b", maxWantLen+1)

	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "want "+oid1)
	gittest.WritePktlineString(t, buf, "want "+sha256OID)
	gittest.WritePktlineString(t, buf, "want "+overlong)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	// A SHA-256 OID is retained in full. Anything longer is not an OID, and a clipped one would
	// be no more resolvable than none at all, so it is dropped but still counted.
	requireParses(t, buf, PackfileNegotiation{
		Wants:       3,
		WantsSample: []string{oid1, sha256OID},
	})
}

func TestPackNegoWantRefSampleClipsOverlongRefs(t *testing.T) {
	exactly := "refs/heads/" + strings.Repeat("a", maxWantRefLen-len("refs/heads/"))
	require.Len(t, exactly, maxWantRefLen)
	overlong := "refs/heads/" + strings.Repeat("b", maxWantRefLen)

	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "want-ref "+exactly)
	gittest.WritePktlineString(t, buf, "want-ref "+overlong)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	// Refnames have no length limit, so an over-long one is clipped and marked rather than
	// dropped: the leading path still says which kind of ref was wanted.
	requireParses(t, buf, PackfileNegotiation{
		Command:  "fetch",
		WantRefs: 2,
		WantRefsSample: []string{
			exactly,
			overlong[:maxWantRefLen] + truncationMarker,
		},
	})
}

func TestPackNegoWantRefSampleClipsOnRuneBoundary(t *testing.T) {
	// Place a multi-byte rune so that it straddles the cut, and pad past the cap so the ref is
	// clipped at all.
	prefix := "refs/heads/" + strings.Repeat("a", maxWantRefLen-len("refs/heads/")-1)
	ref := prefix + "\u00e4" + strings.Repeat("c", maxWantRefLen)

	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=fetch")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "want-ref "+ref)
	gittest.WritePktlineFlush(t, buf)
	gittest.WritePktlineString(t, buf, "done")

	actual, err := ParsePackfileNegotiation(buf)
	require.NoError(t, err)
	require.Equal(t, []string{prefix + truncationMarker}, actual.WantRefsSample)
	require.True(t, utf8.ValidString(actual.WantRefsSample[0]))
}

func TestPackNegoWantsSampleWithoutWants(t *testing.T) {
	buf := &bytes.Buffer{}
	gittest.WritePktlineString(t, buf, "command=ls-refs")
	gittest.WritePktlineDelim(t, buf)
	gittest.WritePktlineString(t, buf, "ref-prefix refs/heads/main")
	gittest.WritePktlineFlush(t, buf)

	requireParses(t, buf, PackfileNegotiation{
		Command: "ls-refs",
	})
}

func TestPackNegoUpdateLogFieldsSamples(t *testing.T) {
	for _, tc := range []struct {
		desc           string
		negotiation    PackfileNegotiation
		expectedFields map[string]any
	}{
		{
			desc:        "wants sample is recorded when present",
			negotiation: PackfileNegotiation{Wants: 2, WantsSample: []string{oid1, oid2}},
			expectedFields: map[string]any{
				"negotiation.wants_sample": []string{oid1, oid2},
			},
		},
		{
			desc:           "wants sample is omitted when empty",
			negotiation:    PackfileNegotiation{Command: "ls-refs"},
			expectedFields: map[string]any{},
		},
		{
			desc:        "want-refs count and sample are recorded when present",
			negotiation: PackfileNegotiation{WantRefs: 1, WantRefsSample: []string{"refs/heads/main"}},
			expectedFields: map[string]any{
				"negotiation.want_refs":        1,
				"negotiation.want_refs_sample": []string{"refs/heads/main"},
			},
		},
		{
			desc:        "want-refs count is recorded when the sample was dropped",
			negotiation: PackfileNegotiation{WantRefs: 1},
			expectedFields: map[string]any{
				"negotiation.want_refs": 1,
			},
		},
		{
			desc: "both samples are recorded independently",
			negotiation: PackfileNegotiation{
				Wants:          1,
				WantsSample:    []string{oid1},
				WantRefs:       1,
				WantRefsSample: []string{"refs/heads/main"},
			},
			expectedFields: map[string]any{
				"negotiation.wants_sample":     []string{oid1},
				"negotiation.want_refs":        1,
				"negotiation.want_refs_sample": []string{"refs/heads/main"},
			},
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			ctx := log.InitContextCustomFields(testhelper.Context(t))

			tc.negotiation.UpdateLogFields(ctx)

			fields := log.CustomFieldsFromContext(ctx).Fields()
			for _, key := range []string{
				"negotiation.wants_sample",
				"negotiation.want_refs",
				"negotiation.want_refs_sample",
			} {
				value, ok := fields[key]
				expected, expectPresent := tc.expectedFields[key]
				require.Equal(t, expectPresent, ok, "unexpected presence of %q", key)
				if expectPresent {
					require.Equal(t, expected, value)
				}
			}
		})
	}
}

func TestPackfileNegotiation_CloneType(t *testing.T) {
	for _, tc := range []struct {
		desc        string
		negotiation PackfileNegotiation
		expected    string
	}{
		{
			desc:        "full clone",
			negotiation: PackfileNegotiation{Wants: 1},
			expected:    "full",
		},
		{
			desc:        "fetch with haves",
			negotiation: PackfileNegotiation{Wants: 1, Haves: 1},
			expected:    "fetch",
		},
		{
			desc:        "shallow via deepen",
			negotiation: PackfileNegotiation{Wants: 1, Deepen: "deepen 1"},
			expected:    "shallow",
		},
		{
			desc:        "shallow via boundaries",
			negotiation: PackfileNegotiation{Wants: 1, Shallows: 2},
			expected:    "shallow",
		},
		{
			desc:        "partial clone",
			negotiation: PackfileNegotiation{Wants: 1, Filter: "blob:none"},
			expected:    "partial",
		},
		{
			desc:        "filter takes precedence over shallow and haves",
			negotiation: PackfileNegotiation{Wants: 1, Haves: 1, Shallows: 1, Deepen: "deepen 1", Filter: "blob:none"},
			expected:    "partial",
		},
		{
			desc:        "shallow takes precedence over haves",
			negotiation: PackfileNegotiation{Wants: 1, Haves: 1, Shallows: 1},
			expected:    "shallow",
		},
	} {
		t.Run(tc.desc, func(t *testing.T) {
			require.Equal(t, tc.expected, tc.negotiation.CloneType())
		})
	}
}