GitLabgitlab-org

cli

main
ply8 git calls234 ms100 KiB6 cachedprotocol v2
397 lines13 KiBRaw
1//go:build !integration
3package prune
5import (
6 "errors"
7 "strings"
8 "testing"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12 "go.uber.org/mock/gomock"
14 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
15 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
17 git_testing "gitlab.com/gitlab-org/cli/internal/git/testing"
18 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
21const fullName = "OWNER/REPO"
23func expectListLocalBranches(mockGit *git_testing.MockGitRunner, branches ...string) {
24 var out strings.Builder
25 for _, b := range branches {
26 out.WriteString(b + "\n")
27 }
28 mockGit.EXPECT().
29 Git("for-each-ref", "--format=%(refname:short)", "refs/heads/").
30 Return(out.String(), nil)
33func expectProject(tc *gitlabtesting.TestClient) {
34 tc.MockProjects.EXPECT().
35 GetProject(fullName, gomock.Any(), gomock.Any()).
36 Return(&gitlab.Project{DefaultBranch: "main"}, &gitlab.Response{}, nil)
39func expectNoProtectedBranches(tc *gitlabtesting.TestClient) {
40 tc.MockProtectedBranches.EXPECT().
41 ListProtectedBranches(fullName, gomock.Any(), gomock.Any(), gomock.Any()).
42 Return(nil, &gitlab.Response{}, nil)
45// expectMRsForBranch sets up the per-branch MR lookup. mrs is the slice
46// returned on the first (and only) page. The expectation matches by
47// SourceBranch only, so the call order across branches doesn't have to
48// align with the order expectations are registered. Extra variadic
49// matchers cover the pagination and WithContext options that
50// gitlab.ScanAndCollect appends.
51func expectMRsForBranch(tc *gitlabtesting.TestClient, branch string, mrs []*gitlab.BasicMergeRequest) {
52 tc.MockMergeRequests.EXPECT().
53 ListProjectMergeRequests(fullName, gomock.Matcher(sourceBranchMatcher(branch)), gomock.Any(), gomock.Any()).
54 Return(mrs, &gitlab.Response{}, nil)
57// sourceBranchMatcher matches a *gitlab.ListProjectMergeRequestsOptions
58// whose SourceBranch points at the expected branch name. Lets per-branch
59// expectations be dispatched by SourceBranch rather than call order.
60type sourceBranchMatcher string
62func (s sourceBranchMatcher) Matches(x any) bool {
63 opts, ok := x.(*gitlab.ListProjectMergeRequestsOptions)
64 if !ok || opts == nil || opts.SourceBranch == nil {
65 return false
66 }
67 return *opts.SourceBranch == string(s)
70func (s sourceBranchMatcher) String() string {
71 return "SourceBranch == " + string(s)
74func TestPrune_DeletesBranchesWithMergedMR(t *testing.T) {
75 t.Parallel()
77 tc := gitlabtesting.NewTestClient(t)
78 expectProject(tc)
79 expectNoProtectedBranches(tc)
80 expectMRsForBranch(tc, "feature/merged", []*gitlab.BasicMergeRequest{{IID: 42, State: "merged", TargetBranch: "main"}})
81 expectMRsForBranch(tc, "feature/open", []*gitlab.BasicMergeRequest{{IID: 43, State: "opened", TargetBranch: "main"}})
82 expectMRsForBranch(tc, "feature/empty", nil)
84 ctrl := gomock.NewController(t)
85 mockGit := git_testing.NewMockGitRunner(ctrl)
86 expectListLocalBranches(mockGit, "main", "feature/merged", "feature/open", "feature/empty")
87 mockGit.EXPECT().Git("branch", "-D", "feature/merged").Return("", nil)
89 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
90 cmdtest.WithGitLabClient(tc.Client),
91 cmdtest.WithGitRunner(mockGit),
92 cmdtest.WithBranch("other-branch"),
93 )
95 out, err := exec("--yes")
96 require.NoError(t, err)
98 stdout := out.OutBuf.String()
99 assert.Contains(t, stdout, "feature/merged")
100 assert.Contains(t, stdout, "(MR !42 → main)")
101 assert.NotContains(t, stdout, "feature/open")
102 assert.NotContains(t, stdout, "feature/empty")
103 assert.Contains(t, stdout, "deleted feature/merged")
104 assert.Contains(t, stdout, "1 branch(es) deleted.")
107func TestPrune_SkipsBranchWithMergedAndOpenMR(t *testing.T) {
108 t.Parallel()
110 tc := gitlabtesting.NewTestClient(t)
111 expectProject(tc)
112 expectNoProtectedBranches(tc)
113 expectMRsForBranch(tc, "feature/reused", []*gitlab.BasicMergeRequest{
114 {IID: 50, State: "merged", TargetBranch: "main"},
115 {IID: 51, State: "opened", TargetBranch: "main"},
116 })
118 ctrl := gomock.NewController(t)
119 mockGit := git_testing.NewMockGitRunner(ctrl)
120 expectListLocalBranches(mockGit, "feature/reused")
122 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
123 cmdtest.WithGitLabClient(tc.Client),
124 cmdtest.WithGitRunner(mockGit),
125 cmdtest.WithBranch("other-branch"),
126 )
128 out, err := exec("--yes")
129 require.NoError(t, err)
131 stdout := out.OutBuf.String()
132 assert.Contains(t, stdout, "No local branches found")
133 assert.NotContains(t, stdout, "feature/reused")
136// TestPrune_OpenMROnLaterPageIsRespected verifies the per-branch MR scan
137// follows pagination — an open MR on page 2 must still cause the branch
138// to be skipped. Regression test for the unpaginated initial implementation.
139func TestPrune_OpenMROnLaterPageIsRespected(t *testing.T) {
140 t.Parallel()
142 tc := gitlabtesting.NewTestClient(t)
143 expectProject(tc)
144 expectNoProtectedBranches(tc)
146 // First page: merged MR + a NextPage hint to drive ScanAndCollect into
147 // the second iteration.
148 tc.MockMergeRequests.EXPECT().
149 ListProjectMergeRequests(fullName, gomock.Any(), gomock.Any(), gomock.Any()).
150 Return(
151 []*gitlab.BasicMergeRequest{{IID: 100, State: "merged", TargetBranch: "main"}},
152 &gitlab.Response{NextPage: 2},
153 nil,
154 )
155 // Second page: an open MR, which must veto the deletion.
156 tc.MockMergeRequests.EXPECT().
157 ListProjectMergeRequests(fullName, gomock.Any(), gomock.Any(), gomock.Any()).
158 Return(
159 []*gitlab.BasicMergeRequest{{IID: 101, State: "opened", TargetBranch: "main"}},
160 &gitlab.Response{},
161 nil,
162 )
164 ctrl := gomock.NewController(t)
165 mockGit := git_testing.NewMockGitRunner(ctrl)
166 expectListLocalBranches(mockGit, "feature/paginated")
168 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
169 cmdtest.WithGitLabClient(tc.Client),
170 cmdtest.WithGitRunner(mockGit),
171 cmdtest.WithBranch("other"),
172 )
174 out, err := exec("--yes")
175 require.NoError(t, err)
176 assert.Contains(t, out.OutBuf.String(), "No local branches found")
179func TestPrune_DryRunDoesNotDelete(t *testing.T) {
180 t.Parallel()
182 tc := gitlabtesting.NewTestClient(t)
183 expectProject(tc)
184 expectNoProtectedBranches(tc)
185 expectMRsForBranch(tc, "feature/merged", []*gitlab.BasicMergeRequest{{IID: 1, State: "merged", TargetBranch: "main"}})
187 ctrl := gomock.NewController(t)
188 mockGit := git_testing.NewMockGitRunner(ctrl)
189 expectListLocalBranches(mockGit, "feature/merged")
190 // no Git("branch", "-D", ...) expected
192 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
193 cmdtest.WithGitLabClient(tc.Client),
194 cmdtest.WithGitRunner(mockGit),
195 cmdtest.WithBranch("other"),
196 )
198 out, err := exec("--dry-run")
199 require.NoError(t, err)
200 assert.Contains(t, out.OutBuf.String(), "Dry run: no branches were deleted.")
203func TestPrune_ExcludesProtectedBranches(t *testing.T) {
204 t.Parallel()
206 tc := gitlabtesting.NewTestClient(t)
207 expectProject(tc)
208 tc.MockProtectedBranches.EXPECT().
209 ListProtectedBranches(fullName, gomock.Any(), gomock.Any(), gomock.Any()).
210 Return([]*gitlab.ProtectedBranch{
211 {Name: "release/*"},
212 {Name: "staging"},
213 }, &gitlab.Response{}, nil)
214 // Only "plain" reaches the MR lookup; the protected entries are filtered out first.
215 expectMRsForBranch(tc, "plain", []*gitlab.BasicMergeRequest{{IID: 12, State: "merged", TargetBranch: "main"}})
217 ctrl := gomock.NewController(t)
218 mockGit := git_testing.NewMockGitRunner(ctrl)
219 expectListLocalBranches(mockGit, "release/1.0", "staging", "plain")
220 mockGit.EXPECT().Git("branch", "-D", "plain").Return("", nil)
222 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
223 cmdtest.WithGitLabClient(tc.Client),
224 cmdtest.WithGitRunner(mockGit),
225 cmdtest.WithBranch("other"),
226 )
228 out, err := exec("--yes")
229 require.NoError(t, err)
231 stdout := out.OutBuf.String()
232 assert.NotContains(t, stdout, "release/1.0")
233 assert.NotContains(t, stdout, "staging")
234 assert.Contains(t, stdout, "deleted plain")
237func TestPrune_ExcludesUserPatterns(t *testing.T) {
238 t.Parallel()
240 tc := gitlabtesting.NewTestClient(t)
241 expectProject(tc)
242 expectNoProtectedBranches(tc)
243 expectMRsForBranch(tc, "feature/keep-me", []*gitlab.BasicMergeRequest{{IID: 3, State: "merged", TargetBranch: "main"}})
245 ctrl := gomock.NewController(t)
246 mockGit := git_testing.NewMockGitRunner(ctrl)
247 expectListLocalBranches(mockGit, "wip-foo", "wip-bar", "feature/keep-me", "demo-branch")
248 mockGit.EXPECT().Git("branch", "-D", "feature/keep-me").Return("", nil)
250 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
251 cmdtest.WithGitLabClient(tc.Client),
252 cmdtest.WithGitRunner(mockGit),
253 cmdtest.WithBranch("other"),
254 )
256 out, err := exec("--exclude wip-*,demo-branch --yes")
257 require.NoError(t, err)
259 stdout := out.OutBuf.String()
260 assert.NotContains(t, stdout, "wip-")
261 assert.NotContains(t, stdout, "demo-branch")
262 assert.Contains(t, stdout, "deleted feature/keep-me")
265func TestPrune_SkipsCurrentBranch(t *testing.T) {
266 t.Parallel()
268 tc := gitlabtesting.NewTestClient(t)
269 expectProject(tc)
270 expectNoProtectedBranches(tc)
271 // "current-branch" is filtered out before any MR lookup happens.
273 ctrl := gomock.NewController(t)
274 mockGit := git_testing.NewMockGitRunner(ctrl)
275 expectListLocalBranches(mockGit, "current-branch")
277 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
278 cmdtest.WithGitLabClient(tc.Client),
279 cmdtest.WithGitRunner(mockGit),
280 cmdtest.WithBranch("current-branch"),
281 )
283 out, err := exec("--yes")
284 require.NoError(t, err)
285 assert.Contains(t, out.OutBuf.String(), "No local branches found")
288func TestPrune_NonInteractiveRequiresYes(t *testing.T) {
289 t.Parallel()
291 tc := gitlabtesting.NewTestClient(t)
292 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
293 cmdtest.WithGitLabClient(tc.Client),
294 cmdtest.WithBranch("main"),
295 )
297 _, err := exec("")
298 require.Error(t, err)
299 assert.Contains(t, err.Error(), "--yes")
302func TestPrune_ProtectedBranchesAPIFailureIsHardError(t *testing.T) {
303 t.Parallel()
305 tc := gitlabtesting.NewTestClient(t)
306 expectProject(tc)
307 tc.MockProtectedBranches.EXPECT().
308 ListProtectedBranches(fullName, gomock.Any(), gomock.Any(), gomock.Any()).
309 Return(nil, nil, errors.New("forbidden"))
311 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
312 cmdtest.WithGitLabClient(tc.Client),
313 cmdtest.WithBranch("main"),
314 )
316 _, err := exec("--yes")
317 require.Error(t, err)
318 assert.Contains(t, err.Error(), "protected branches")
321func TestPrune_MergedFlagUsesGit(t *testing.T) {
322 t.Parallel()
324 tc := gitlabtesting.NewTestClient(t)
325 expectProject(tc)
326 expectNoProtectedBranches(tc)
327 // No MR-lookup mock is set up — if --merged accidentally invokes the
328 // per-branch API path, gomock will fail the test for an unexpected call.
330 ctrl := gomock.NewController(t)
331 mockGit := git_testing.NewMockGitRunner(ctrl)
332 expectListLocalBranches(mockGit, "ff-merged", "not-merged")
333 mockGit.EXPECT().
334 Git("branch", "--merged", "main", "--format=%(refname:short)").
335 Return("ff-merged\n", nil)
336 mockGit.EXPECT().Git("branch", "-D", "ff-merged").Return("", nil)
338 exec := cmdtest.SetupCmdForTest(t, NewCmd, false,
339 cmdtest.WithGitLabClient(tc.Client),
340 cmdtest.WithGitRunner(mockGit),
341 cmdtest.WithBranch("other"),
342 )
344 out, err := exec("--merged --yes")
345 require.NoError(t, err)
347 stdout := out.OutBuf.String()
348 assert.Contains(t, stdout, "deleted ff-merged")
349 assert.NotContains(t, stdout, "deleted not-merged")
350 // In --merged mode the header should reference the target branch, not MRs.
351 assert.Contains(t, stdout, "Found 1 branch(es) merged into main:")
352 assert.NotContains(t, stdout, "merged merge requests")
355func TestBuildMatcher(t *testing.T) {
356 t.Parallel()
358 cases := []struct {
359 name string
360 protected []string
361 userPatterns []string
362 branch string
363 wantExcluded bool
364 }{
365 {name: "literal match", protected: []string{"main"}, branch: "main", wantExcluded: true},
366 {name: "literal non-match", protected: []string{"main"}, branch: "develop"},
367 {name: "star matches non-slash", protected: []string{"wip-*"}, branch: "wip-foo", wantExcluded: true},
368 // Regression: GitLab protected-branch wildcards match across `/`, unlike filepath.Match.
369 {name: "star matches across slash", protected: []string{"release*"}, branch: "release/1.0", wantExcluded: true},
370 {name: "star prefix with slash", protected: []string{"release/*"}, branch: "release/1.0", wantExcluded: true},
371 {name: "star matches empty", protected: []string{"release/*"}, branch: "release/", wantExcluded: true},
372 {name: "question mark matches one char", protected: []string{"feature/?"}, branch: "feature/a", wantExcluded: true},
373 {name: "question mark does not match many", protected: []string{"feature/?"}, branch: "feature/abc"},
374 {name: "no patterns matches nothing", branch: "anything"},
375 {name: "user pattern comma split", userPatterns: []string{"a,b"}, branch: "b", wantExcluded: true},
376 {name: "user wildcard", userPatterns: []string{"wip-*"}, branch: "wip-x", wantExcluded: true},
377 }
378 for _, tc := range cases {
379 t.Run(tc.name, func(t *testing.T) {
380 t.Parallel()
381 excluded := buildMatcher("", "", tc.protected, tc.userPatterns)
382 assert.Equal(t, tc.wantExcluded, excluded(tc.branch))
383 })
384 }
387// TestBuildMatcher_ProtectedWildcardAcrossSlash isolates the specific
388// failure mode Gary flagged in review: filepath.Match would have left
389// release/1.0 unexcluded against a release* pattern.
390func TestBuildMatcher_ProtectedWildcardAcrossSlash(t *testing.T) {
391 t.Parallel()
393 excluded := buildMatcher("", "", []string{"release*"}, nil)
394 assert.True(t, excluded("release/1.0"), "release* should match release/1.0 under GitLab wildcard semantics")
395 assert.True(t, excluded("release-rc"), "release* should match release-rc")
396 assert.False(t, excluded("hotfix/1.0"))
Diagnostics8 git calls · 234 ms
CallStatusSizeTime0234 ms
discover200185 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit1 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=1
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=1
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchtree:02001.8 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=1857
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1857
git.pkt.payload.max=1830
git.sideband.band1.bytes=1830
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1830
git.pack.trailer=fb03183b7909876778f740d196d7516811003517
Open pack map
fetchtree:0200614 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=614
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=3a89d0cfc8e81880c982180388e42e561a0b7eee
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=614
git.pkt.payload.max=587
git.sideband.band1.bytes=587
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=587
git.pack.trailer=eb8250f8e8340ff2fafc22c5aba90db34fd906a9
Open pack map
fetchtree:0200137 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=137
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=3c308ef932a119b9e19157e3837ba7ff25c96d51
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=137
git.pkt.payload.max=110
git.sideband.band1.bytes=110
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=110
git.pack.trailer=9cb9fcd588b8f9432d9a73173cf6d274049bcbeb
Open pack map
fetch2002.9 KiB224 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=224
git.response.bytes=2988
git.response.cache=MISS
git.response.duration_ms=224
git.fetch.wants=9f66aaf521b9fd608ddb5e66ed7b63cb3dfc49de
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=2988
git.pkt.payload.max=2961
git.sideband.band1.bytes=2961
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://gitlab.com/gitlab-org/cli
Ref
refs/heads/main
Commit
0dd7574dce9e385c5c30540e6c15657adc6bdce9
cf-ray
a5ea5695ef957089
Request
6385ad04…
Protocol
v2 · sha1
Agent
git/2.56.g1891de4-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format