GitLabgitlab-org

cli

main
ply6 git calls50 ms99 KiB5 cachedprotocol v2
629 lines15 KiBRaw
1//go:build !integration
3package git
5import (
6 "encoding/json"
7 "os"
8 "path/filepath"
9 "strings"
10 "testing"
12 "github.com/stretchr/testify/require"
14 "gitlab.com/gitlab-org/cli/internal/config"
17func TestSetLocalConfig(t *testing.T) {
18 tests := []struct {
19 name string
20 value string
21 existingConfig bool
22 }{
23 {
24 name: "config already exists",
25 value: "exciting new value",
26 existingConfig: true,
27 },
28 {
29 name: "config doesn't exist",
30 value: "default value",
31 existingConfig: false,
32 },
33 }
34 for _, tt := range tests {
35 t.Run(tt.name, func(t *testing.T) {
36 tempDir := InitGitRepo(t)
37 defer os.RemoveAll(tempDir)
39 if tt.existingConfig {
40 _ = GitCommand("config", "--local", "this.glabstacks", "prev-value")
41 }
43 err := SetLocalConfig("this.glabstacks", tt.value)
44 require.NoError(t, err)
46 config, err := GetAllConfig("this.glabstacks")
47 require.NoError(t, err)
49 // GetAllConfig() appends a new line. Let's get rid of that.
50 compareString := strings.TrimSuffix(string(config), "\n")
52 if compareString != tt.value {
53 t.Errorf("config value = %v, want %v", compareString, tt.value)
54 }
55 })
56 }
59func Test_AddStackRefDir(t *testing.T) {
60 tests := []struct {
61 name string
62 branch string
63 worktree bool
64 }{
65 {
66 name: "normal filename",
67 branch: "thing",
68 },
69 {
70 name: "advanced filename",
71 branch: "something-with-dashes",
72 },
73 {
74 name: "normal filename in worktree",
75 branch: "thing",
76 worktree: true,
77 },
78 {
79 name: "advanced filename in worktree",
80 branch: "something-with-dashes",
81 worktree: true,
82 },
83 }
84 for _, tt := range tests {
85 t.Run(tt.name, func(t *testing.T) {
86 InitGitRepoOrWorktree(t, tt.worktree)
88 _, err := AddStackRefDir(tt.branch)
89 require.NoError(t, err)
91 stackLoc, locErr := StackLocation()
92 require.NoError(t, locErr)
94 _, err = os.Stat(filepath.Join(stackLoc, tt.branch))
95 require.NoError(t, err)
97 if tt.worktree {
98 // Ensure nothing was written to the per-worktree git dir.
99 gitDir, err := GitDir()
100 require.NoError(t, err)
101 require.NoDirExists(t, filepath.Join(gitDir, "stacked"))
102 }
103 })
104 }
107func Test_StackRootDir(t *testing.T) {
108 tests := []struct {
109 name string
110 title string
111 worktree bool
112 }{
113 {
114 name: "valid title",
115 title: "test-stack",
116 },
117 {
118 name: "empty title",
119 title: "",
120 },
121 {
122 name: "valid title in worktree",
123 title: "test-stack",
124 worktree: true,
125 },
126 }
128 for _, tt := range tests {
129 t.Run(tt.name, func(t *testing.T) {
130 InitGitRepoOrWorktree(t, tt.worktree)
132 got, err := StackRootDir(tt.title)
133 require.NoError(t, err)
135 // Verify the path contains the expected components
136 require.Contains(t, got, "stacked", "StackRootDir() should contain stacked dir name")
137 require.Contains(t, got, tt.title, "StackRootDir() should contain title")
139 if tt.worktree {
140 // Verify it resolves to the common git dir, not the per-worktree one.
141 commonDir, err := GitCommonDir()
142 require.NoError(t, err)
143 require.True(t, strings.HasPrefix(got, commonDir), "StackRootDir() should be under common git dir")
144 }
145 })
146 }
149func Test_AddStackRefFile(t *testing.T) {
150 type args struct {
151 title string
152 stackRef StackRef
153 }
154 tests := []struct {
155 name string
156 args args
157 worktree bool
158 wantErr bool
159 }{
160 {
161 name: "no message",
162 args: args{
163 title: "sweet-title-123",
164 stackRef: StackRef{
165 Prev: "hello",
166 Branch: "gmh-feature-3ab3da",
167 Next: "goodbye",
168 SHA: "1a2b3c4d",
169 MR: "https://gitlab.com/",
170 },
171 },
172 wantErr: true,
173 },
174 {
175 name: "no message in worktree",
176 worktree: true,
177 args: args{
178 title: "sweet-title-123",
179 stackRef: StackRef{
180 Prev: "hello",
181 Branch: "gmh-feature-3ab3da",
182 Next: "goodbye",
183 SHA: "1a2b3c4d",
184 MR: "https://gitlab.com/",
185 },
186 },
187 wantErr: true,
188 },
189 }
190 for _, tt := range tests {
191 t.Run(tt.name, func(t *testing.T) {
192 InitGitRepoOrWorktree(t, tt.worktree)
194 err := AddStackRefFile(tt.args.title, tt.args.stackRef)
195 require.NoError(t, err)
197 stackLoc, locErr := StackLocation()
198 require.NoError(t, locErr)
199 file := filepath.Join(stackLoc, tt.args.title, tt.args.stackRef.SHA+".json")
200 require.True(t, config.CheckFileExists(file))
202 stackRef := StackRef{}
203 readData, err := os.ReadFile(file)
204 require.NoError(t, err)
206 err = json.Unmarshal(readData, &stackRef)
207 require.NoError(t, err)
209 require.Equal(t, stackRef, tt.args.stackRef)
211 if tt.worktree {
212 gitDir, err := GitDir()
213 require.NoError(t, err)
214 require.NoDirExists(t, filepath.Join(gitDir, "stacked"))
215 }
216 })
217 }
220func Test_DeleteStackRefFile(t *testing.T) {
221 // TODO: write test
224func Test_UnsetLocalConfig(t *testing.T) {
225 InitGitRepo(t)
227 require.NoError(t, SetLocalConfig("this.glabstacks", "a value"))
229 require.NoError(t, UnsetLocalConfig("this.glabstacks"))
231 _, err := Config("this.glabstacks")
232 require.Error(t, err, "the key should be gone")
235func Test_RemoveStackRefDir(t *testing.T) {
236 for _, worktree := range []bool{false, true} {
237 suffix := ""
238 if worktree {
239 suffix = " in worktree"
240 }
242 t.Run("removes the stack and its files"+suffix, func(t *testing.T) {
243 InitGitRepoOrWorktree(t, worktree)
245 require.NoError(t, AddStackRefFile("doomed-stack", StackRef{SHA: "1a2b3c4d", Branch: "a-branch"}))
246 require.NoError(t, AddStackRefFile("keeper-stack", StackRef{SHA: "5e6f7a8b", Branch: "another-branch"}))
248 require.NoError(t, RemoveStackRefDir("doomed-stack"))
250 stackLoc, err := StackLocation()
251 require.NoError(t, err)
252 require.NoDirExists(t, filepath.Join(stackLoc, "doomed-stack"))
253 require.DirExists(t, filepath.Join(stackLoc, "keeper-stack"))
254 })
255 }
257 t.Run("removes a stack left with only a BASE_BRANCH file", func(t *testing.T) {
258 InitGitRepo(t)
260 stackDir, err := AddStackRefDir("merged-stack")
261 require.NoError(t, err)
262 require.NoError(t, os.WriteFile(filepath.Join(stackDir, BaseBranchFile), []byte("main"), 0o644))
264 require.NoError(t, RemoveStackRefDir("merged-stack"))
265 require.NoDirExists(t, stackDir)
266 })
268 t.Run("refuses a name that escapes the stacked directory", func(t *testing.T) {
269 InitGitRepo(t)
271 require.NoError(t, AddStackRefFile("real-stack", StackRef{SHA: "1a2b3c4d", Branch: "a-branch"}))
273 for _, name := range []string{"", ".", "..", "../..", "nested/stack"} {
274 require.Error(t, RemoveStackRefDir(name), "name %q should be rejected", name)
275 }
277 gitDir, err := GitDir()
278 require.NoError(t, err)
279 require.DirExists(t, gitDir)
281 stackLoc, err := StackLocation()
282 require.NoError(t, err)
283 require.DirExists(t, filepath.Join(stackLoc, "real-stack"))
284 })
287func Test_UpdateStackRefFile(t *testing.T) {
288 type args struct {
289 title string
290 stackRef StackRef
291 }
292 tests := []struct {
293 name string
294 args args
295 worktree bool
296 wantErr bool
297 }{
298 {
299 name: "no message",
300 args: args{
301 title: "sweet-title-123",
302 stackRef: StackRef{
303 Prev: "hello",
304 Branch: "gmh-feature-3ab3da",
305 Next: "goodbye",
306 SHA: "1a2b3c4d",
307 MR: "https://gitlab.com/",
308 },
309 },
310 wantErr: true,
311 },
312 {
313 name: "no message in worktree",
314 worktree: true,
315 args: args{
316 title: "sweet-title-123",
317 stackRef: StackRef{
318 Prev: "hello",
319 Branch: "gmh-feature-3ab3da",
320 Next: "goodbye",
321 SHA: "1a2b3c4d",
322 MR: "https://gitlab.com/",
323 },
324 },
325 wantErr: true,
326 },
327 }
328 for _, tt := range tests {
329 t.Run(tt.name, func(t *testing.T) {
330 InitGitRepoOrWorktree(t, tt.worktree)
332 // add the initial data
333 initial := StackRef{Prev: "123", Branch: "gmh"}
334 err := AddStackRefFile(tt.args.title, initial)
335 require.NoError(t, err)
337 err = UpdateStackRefFile(tt.args.title, tt.args.stackRef)
339 require.NoError(t, err)
341 stackLoc, locErr := StackLocation()
342 require.NoError(t, locErr)
343 file := filepath.Join(stackLoc, tt.args.title, tt.args.stackRef.SHA+".json")
344 require.True(t, config.CheckFileExists(file))
346 stackRef := StackRef{}
347 readData, err := os.ReadFile(file)
348 require.NoError(t, err)
350 err = json.Unmarshal(readData, &stackRef)
351 require.NoError(t, err)
353 require.Equal(t, stackRef, tt.args.stackRef)
355 if tt.worktree {
356 gitDir, err := GitDir()
357 require.NoError(t, err)
358 require.NoDirExists(t, filepath.Join(gitDir, "stacked"))
359 }
360 })
361 }
364func Test_GetStacks(t *testing.T) {
365 stacks := []Stack{
366 {
367 Title: "stack-0",
368 Refs: map[string]StackRef{
369 "0": {
370 Description: "stack-0 initial commit",
371 },
372 },
373 },
374 {
375 Title: "stack-1",
376 Refs: map[string]StackRef{
377 "0": {
378 Description: "stack-1 initial commit",
379 },
380 },
381 },
382 }
384 for _, worktree := range []bool{false, true} {
385 suffix := ""
386 if worktree {
387 suffix = " in worktree"
388 }
390 t.Run("two stacks"+suffix, func(t *testing.T) {
391 InitGitRepoOrWorktree(t, worktree)
392 var want []Stack
393 for _, v := range stacks {
394 for _, ref := range v.Refs {
395 err := AddStackRefFile(v.Title, ref)
396 require.NoError(t, err)
397 }
398 want = append(want, Stack{Title: v.Title})
399 }
400 got, err := GetStacks()
401 require.NoError(t, err)
402 require.Equal(t, want, got)
404 if worktree {
405 gitDir, err := GitDir()
406 require.NoError(t, err)
407 require.NoDirExists(t, filepath.Join(gitDir, "stacked"))
408 }
409 })
410 t.Run("no stacks"+suffix, func(t *testing.T) {
411 InitGitRepoOrWorktree(t, worktree)
412 got, err := GetStacks()
413 var want []Stack = nil
414 require.Error(t, err)
415 require.Equal(t, want, got)
416 })
417 }
420func Test_WriteAndReadReorderState(t *testing.T) {
421 InitGitRepo(t)
423 state := ReorderState{
424 NewOrder: []string{"branchC", "branchA", "branchB"},
425 NextIndex: 1,
426 OldTips: map[string]string{"branchA": "aaa", "branchB": "bbb", "branchC": "ccc", "main": "000"},
427 OldParent: map[string]string{"branchA": "main", "branchB": "branchA", "branchC": "branchB"},
428 BaseBranch: "main",
429 OriginalBranch: "branchA",
430 OldRefs: map[string]StackRef{
431 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
432 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "ref-c", Branch: "branchB"},
433 "ref-c": {SHA: "ref-c", Prev: "ref-b", Next: "", Branch: "branchC"},
434 },
435 NewRefs: map[string]StackRef{
436 "ref-c": {SHA: "ref-c", Prev: "", Next: "ref-a", Branch: "branchC"},
437 "ref-a": {SHA: "ref-a", Prev: "ref-c", Next: "ref-b", Branch: "branchA"},
438 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
439 },
440 }
442 // Create the stack directory first
443 err := AddStackRefFile("test-stack", StackRef{SHA: "dummy"})
444 require.NoError(t, err)
446 err = WriteReorderState("test-stack", state)
447 require.NoError(t, err)
449 got, err := ReadReorderState("test-stack")
450 require.NoError(t, err)
451 require.Equal(t, state, got)
454func Test_DeleteReorderState(t *testing.T) {
455 InitGitRepo(t)
457 // Create directory and write state
458 err := AddStackRefFile("test-stack", StackRef{SHA: "dummy"})
459 require.NoError(t, err)
461 state := ReorderState{NewOrder: []string{"a"}}
462 err = WriteReorderState("test-stack", state)
463 require.NoError(t, err)
465 // Verify it exists
466 inProgress, err := ReorderInProgress("test-stack")
467 require.NoError(t, err)
468 require.True(t, inProgress)
470 err = DeleteReorderState("test-stack")
471 require.NoError(t, err)
473 // Verify it's gone
474 inProgress, err = ReorderInProgress("test-stack")
475 require.NoError(t, err)
476 require.False(t, inProgress)
479func Test_ReorderInProgress(t *testing.T) {
480 InitGitRepo(t)
482 // Create the stack directory
483 err := AddStackRefFile("test-stack", StackRef{SHA: "dummy"})
484 require.NoError(t, err)
486 // No state file yet
487 inProgress, err := ReorderInProgress("test-stack")
488 require.NoError(t, err)
489 require.False(t, inProgress)
491 // Write state
492 state := ReorderState{NewOrder: []string{"a"}}
493 err = WriteReorderState("test-stack", state)
494 require.NoError(t, err)
496 // Now it should be in progress
497 inProgress, err = ReorderInProgress("test-stack")
498 require.NoError(t, err)
499 require.True(t, inProgress)
502func Test_ReadReorderState_NotExist(t *testing.T) {
503 InitGitRepo(t)
505 // Create the stack directory but no state file
506 err := AddStackRefFile("test-stack", StackRef{SHA: "dummy"})
507 require.NoError(t, err)
509 _, err = ReadReorderState("test-stack")
510 require.ErrorIs(t, err, os.ErrNotExist)
513func Test_StackLocation_SharedAcrossWorktrees(t *testing.T) {
514 repo := NewTestRepo(t)
515 worktreeDir1 := repo.addWorktree(t)
516 worktreeDir2 := repo.addWorktree(t)
518 // Create a stack from worktree 1.
519 t.Chdir(worktreeDir1)
520 ref1 := StackRef{SHA: "abc123", Branch: "wt1-branch"}
521 err := AddStackRefFile("shared-stack", ref1)
522 require.NoError(t, err)
524 // Verify it is visible from worktree 2.
525 t.Chdir(worktreeDir2)
526 stacks, err := GetStacks()
527 require.NoError(t, err)
528 require.Len(t, stacks, 1)
529 require.Equal(t, "shared-stack", stacks[0].Title)
531 // Verify the file is in the common dir, not in either worktree git dir.
532 commonDir, err := GitCommonDir()
533 require.NoError(t, err)
534 require.FileExists(t, filepath.Join(commonDir, "stacked", "shared-stack", "abc123.json"))
536 gitDir1, err := GitDir()
537 require.NoError(t, err)
538 require.NoDirExists(t, filepath.Join(gitDir1, "stacked"))
541func Test_CurrentStackTitle_IsolatedPerWorktree(t *testing.T) {
542 repo := NewTestRepo(t)
543 require.NoError(t, SetCurrentStackTitle("stack-alpha"))
545 worktreeDir := repo.addWorktree(t)
546 require.NoError(t, SetCurrentStackTitle("stack-beta"))
548 t.Chdir(repo.rootDir)
549 title, err := GetCurrentStackTitle()
550 require.NoError(t, err)
551 require.Equal(t, "stack-alpha", title)
553 t.Chdir(worktreeDir)
554 title, err = GetCurrentStackTitle()
555 require.NoError(t, err)
556 require.Equal(t, "stack-beta", title)
559func Test_CurrentStackTitle_FallsBackToLegacyConfig(t *testing.T) {
560 repo := NewTestRepo(t)
561 require.NoError(t, SetLocalConfig(legacyCurrentStackKey, "legacy-stack"))
562 repo.addWorktree(t)
564 title, err := GetCurrentStackTitle()
565 require.NoError(t, err)
566 require.Equal(t, "legacy-stack", title)
568 require.NoError(t, SetCurrentStackTitle("new-stack"))
569 title, err = GetCurrentStackTitle()
570 require.NoError(t, err)
571 require.Equal(t, "new-stack", title)
573 t.Chdir(repo.rootDir)
574 title, err = GetCurrentStackTitle()
575 require.NoError(t, err)
576 require.Equal(t, "legacy-stack", title)
579func Test_CurrentStackTitle_NotSet(t *testing.T) {
580 InitGitRepo(t)
582 _, err := GetCurrentStackTitle()
583 require.ErrorIs(t, err, ErrNoCurrentStack)
586func Test_CurrentStackTitle_ReadErrorIsNotNoCurrentStack(t *testing.T) {
587 InitGitRepo(t)
588 path, err := currentStackPath()
589 require.NoError(t, err)
590 require.NoError(t, os.Mkdir(path, 0o755))
592 _, err = GetCurrentStackTitle()
593 require.Error(t, err)
594 require.NotErrorIs(t, err, ErrNoCurrentStack)
597func Test_ClearCurrentStackTitle(t *testing.T) {
598 tests := []struct {
599 name string
600 legacy string
601 wantLegacy bool
602 }{
603 {name: "without legacy config"},
604 {name: "legacy config names the cleared stack", legacy: "doomed-stack"},
605 {name: "legacy config names another stack", legacy: "other-stack", wantLegacy: true},
606 }
608 for _, tc := range tests {
609 t.Run(tc.name, func(t *testing.T) {
610 InitGitRepo(t)
611 if tc.legacy != "" {
612 require.NoError(t, SetLocalConfig(legacyCurrentStackKey, tc.legacy))
613 }
614 require.NoError(t, SetCurrentStackTitle("doomed-stack"))
616 require.NoError(t, ClearCurrentStackTitle("doomed-stack"))
618 _, err := GetCurrentStackTitle()
619 require.ErrorIs(t, err, ErrNoCurrentStack)
621 _, err = Config(legacyCurrentStackKey)
622 if tc.wantLegacy {
623 require.NoError(t, err)
624 } else {
625 require.Error(t, err)
626 }
627 })
628 }
Diagnostics6 git calls · 50 ms
CallStatusSizeTime050 ms
discover200185 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
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 · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=2
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 · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=3
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 · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=3
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:0200510 B · hit1 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=510
git.response.cache=HIT
git.response.duration_ms=1
git.fetch.filter=tree:0
git.fetch.wants=a3147172443266d011121808a125248c5c915972
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=510
git.pkt.payload.max=483
git.sideband.band1.bytes=483
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=483
git.pack.trailer=4ef234d86a93490a6a3da3549aa13a474a5c9eac
Open pack map
fetch2003.2 KiB · hit44 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=44
git.response.bytes=3249
git.response.cache=HIT
git.response.duration_ms=44
git.fetch.wants=4fcb4bc3e3c26d6bbd08d8f82e4fe16dc4110a09
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=3249
git.pkt.payload.max=3222
git.sideband.band1.bytes=3222
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
a5e1c4c7adb8227c
Request
8844cfd3…
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