GitLabgitlab-org

cli

main
ply8 git calls215 ms100 KiB6 cachedprotocol v2
561 lines16 KiBRaw
1//go:build !integration
3package infer
5import (
6 "fmt"
7 "testing"
8 "time"
10 "github.com/MakeNowJust/heredoc/v2"
11 "github.com/spf13/cobra"
12 "github.com/stretchr/testify/assert"
13 "github.com/stretchr/testify/require"
14 "go.uber.org/mock/gomock"
16 "gitlab.com/gitlab-org/cli/internal/cmdutils"
17 "gitlab.com/gitlab-org/cli/internal/commands/stack/stackutils"
18 "gitlab.com/gitlab-org/cli/internal/config"
19 "gitlab.com/gitlab-org/cli/internal/git"
20 git_testing "gitlab.com/gitlab-org/cli/internal/git/testing"
21 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
24func TestGenerateStackSha(t *testing.T) {
25 t.Setenv("NO_COLOR", "true")
27 t.Run("produces deterministic output for same inputs", func(t *testing.T) {
28 ts := fixedTime()
29 sha1, err := stackutils.GenerateStackSha("msg", "title", "author", ts)
30 require.NoError(t, err)
32 sha2, err := stackutils.GenerateStackSha("msg", "title", "author", ts)
33 require.NoError(t, err)
35 assert.Equal(t, sha1, sha2)
36 })
38 t.Run("produces different output for different inputs", func(t *testing.T) {
39 ts := fixedTime()
40 sha1, err := stackutils.GenerateStackSha("msg1", "title", "author", ts)
41 require.NoError(t, err)
43 sha2, err := stackutils.GenerateStackSha("msg2", "title", "author", ts)
44 require.NoError(t, err)
46 assert.NotEqual(t, sha1, sha2)
47 })
49 t.Run("returns 8 hex characters", func(t *testing.T) {
50 sha, err := stackutils.GenerateStackSha("msg", "title", "author", fixedTime())
51 require.NoError(t, err)
52 assert.Len(t, sha, 8)
53 })
56func TestCreateShaBranch(t *testing.T) {
57 t.Setenv("NO_COLOR", "true")
58 t.Setenv("BRANCH_PREFIX", "")
60 t.Run("uses configured branch prefix", func(t *testing.T) {
61 git.InitGitRepo(t)
63 factory := createFactoryWithConfig("myprefix")
65 branch, err := stackutils.CreateShaBranch(factory, "abcd1234", "my-stack")
66 require.NoError(t, err)
67 assert.Equal(t, "myprefix-my-stack-abcd1234", branch)
68 })
71func TestCreateBranches(t *testing.T) {
72 t.Setenv("NO_COLOR", "true")
73 t.Setenv("USER", "testuser")
75 t.Run("creates branches and ref files for each commit", func(t *testing.T) {
76 dir := git.InitGitRepoWithCommit(t)
78 stackTitle := "test-stack"
79 err := git.SetCurrentStackTitle(stackTitle)
80 require.NoError(t, err)
82 _, err = git.AddStackRefDir(stackTitle)
83 require.NoError(t, err)
85 err = git.AddStackBaseBranch(stackTitle, "main")
86 require.NoError(t, err)
88 ctrl := gomock.NewController(t)
89 mockGR := git_testing.NewMockGitRunner(ctrl)
91 mockGR.EXPECT().
92 Git("symbolic-ref", "--quiet", "--short", "HEAD").
93 Return("feature-branch", nil)
95 mockGR.EXPECT().
96 Git("log", "-1", "--format=%s", "abc123").
97 Return("First commit", nil)
98 mockGR.EXPECT().
99 Git("checkout", "-b", gomock.Any(), "main").
100 Return("", nil)
101 mockGR.EXPECT().
102 Git("cherry-pick", "abc123").
103 Return("", nil)
105 mockGR.EXPECT().
106 Git("log", "-1", "--format=%s", "def456").
107 Return("Second commit", nil)
108 mockGR.EXPECT().
109 Git("checkout", "-b", gomock.Any(), gomock.Any()).
110 Return("", nil)
111 mockGR.EXPECT().
112 Git("cherry-pick", "def456").
113 Return("", nil)
115 mockGR.EXPECT().
116 Git("checkout", "feature-branch").
117 Return("", nil)
119 factory := createFactoryWithConfig("test")
121 emptyStack := git.Stack{Title: stackTitle, Refs: make(map[string]git.StackRef)}
122 commits := []string{"abc123", "def456"}
124 err = createBranches(factory, mockGR, commits, stackTitle, emptyStack)
125 require.NoError(t, err)
127 stack, err := git.GatherStackRefs(stackTitle)
128 require.NoError(t, err)
129 assert.Len(t, stack.Refs, 2)
131 first := stack.First()
132 assert.Equal(t, "First commit", first.Description)
133 assert.True(t, first.IsFirst())
134 assert.False(t, first.IsLast())
136 last := stack.Last()
137 assert.Equal(t, "Second commit", last.Description)
138 assert.False(t, last.IsFirst())
139 assert.True(t, last.IsLast())
141 assert.Equal(t, first.Next, last.SHA)
142 assert.Equal(t, last.Prev, first.SHA)
144 _ = dir
145 })
147 t.Run("appends to existing stack", func(t *testing.T) {
148 dir := git.InitGitRepoWithCommit(t)
150 stackTitle := "test-stack"
151 err := git.SetCurrentStackTitle(stackTitle)
152 require.NoError(t, err)
154 _, err = git.AddStackRefDir(stackTitle)
155 require.NoError(t, err)
157 err = git.AddStackBaseBranch(stackTitle, "main")
158 require.NoError(t, err)
160 existingRef := git.StackRef{
161 SHA: "existing01",
162 Branch: "test-test-stack-existing01",
163 Description: "Existing layer",
164 }
165 err = git.AddStackRefFile(stackTitle, existingRef)
166 require.NoError(t, err)
168 ctrl := gomock.NewController(t)
169 mockGR := git_testing.NewMockGitRunner(ctrl)
171 mockGR.EXPECT().
172 Git("symbolic-ref", "--quiet", "--short", "HEAD").
173 Return("feature-branch", nil)
175 mockGR.EXPECT().
176 Git("log", "-1", "--format=%s", "newcommit").
177 Return("New commit", nil)
178 mockGR.EXPECT().
179 Git("checkout", "-b", gomock.Any(), "test-test-stack-existing01").
180 Return("", nil)
181 mockGR.EXPECT().
182 Git("cherry-pick", "newcommit").
183 Return("", nil)
185 mockGR.EXPECT().
186 Git("checkout", "feature-branch").
187 Return("", nil)
189 factory := createFactoryWithConfig("test")
191 existingStack, err := git.GatherStackRefs(stackTitle)
192 require.NoError(t, err)
193 require.Len(t, existingStack.Refs, 1)
195 err = createBranches(factory, mockGR, []string{"newcommit"}, stackTitle, existingStack)
196 require.NoError(t, err)
198 stack, err := git.GatherStackRefs(stackTitle)
199 require.NoError(t, err)
200 assert.Len(t, stack.Refs, 2)
202 first := stack.First()
203 assert.Equal(t, "Existing layer", first.Description)
205 last := stack.Last()
206 assert.Equal(t, "New commit", last.Description)
207 assert.Equal(t, first.SHA, last.Prev)
209 _ = dir
210 })
212 t.Run("rolls back on cherry-pick conflict", func(t *testing.T) {
213 dir := git.InitGitRepoWithCommit(t)
215 stackTitle := "test-stack"
216 err := git.SetCurrentStackTitle(stackTitle)
217 require.NoError(t, err)
219 _, err = git.AddStackRefDir(stackTitle)
220 require.NoError(t, err)
222 err = git.AddStackBaseBranch(stackTitle, "main")
223 require.NoError(t, err)
225 ctrl := gomock.NewController(t)
226 mockGR := git_testing.NewMockGitRunner(ctrl)
228 mockGR.EXPECT().
229 Git("symbolic-ref", "--quiet", "--short", "HEAD").
230 Return("feature-branch", nil)
232 mockGR.EXPECT().
233 Git("log", "-1", "--format=%s", "abc123").
234 Return("First commit", nil)
235 mockGR.EXPECT().
236 Git("checkout", "-b", gomock.Any(), "main").
237 Return("", nil)
238 mockGR.EXPECT().
239 Git("cherry-pick", "abc123").
240 Return("", nil)
242 mockGR.EXPECT().
243 Git("log", "-1", "--format=%s", "def456").
244 Return("Conflicting commit", nil)
245 mockGR.EXPECT().
246 Git("checkout", "-b", gomock.Any(), gomock.Any()).
247 Return("", nil)
248 mockGR.EXPECT().
249 Git("cherry-pick", "def456").
250 Return("", fmt.Errorf("conflict"))
252 mockGR.EXPECT().
253 Git("cherry-pick", "--abort").
254 Return("", nil)
256 mockGR.EXPECT().
257 Git("checkout", "feature-branch").
258 Return("", nil).Times(2)
260 mockGR.EXPECT().
261 Git("branch", "-D", gomock.Any()).
262 Return("", nil).Times(2)
264 factory := createFactoryWithConfig("test")
266 emptyStack := git.Stack{Title: stackTitle, Refs: make(map[string]git.StackRef)}
267 err = createBranches(factory, mockGR, []string{"abc123", "def456"}, stackTitle, emptyStack)
268 require.Error(t, err)
269 assert.Contains(t, err.Error(), "conflict cherry-picking commit 2/2")
271 stack, err := git.GatherStackRefs(stackTitle)
272 require.NoError(t, err)
273 assert.Empty(t, stack.Refs)
275 _ = dir
276 })
278 t.Run("rolls back modified existing ref on cherry-pick conflict", func(t *testing.T) {
279 dir := git.InitGitRepoWithCommit(t)
281 stackTitle := "test-stack"
282 err := git.SetCurrentStackTitle(stackTitle)
283 require.NoError(t, err)
285 _, err = git.AddStackRefDir(stackTitle)
286 require.NoError(t, err)
288 err = git.AddStackBaseBranch(stackTitle, "main")
289 require.NoError(t, err)
291 // Create an existing stack layer (simulates a previous "infer" or "save")
292 existingRef := git.StackRef{
293 SHA: "existing01",
294 Branch: "test-test-stack-existing01",
295 Description: "Existing layer",
296 }
297 err = git.AddStackRefFile(stackTitle, existingRef)
298 require.NoError(t, err)
300 ctrl := gomock.NewController(t)
301 mockGR := git_testing.NewMockGitRunner(ctrl)
303 mockGR.EXPECT().
304 Git("symbolic-ref", "--quiet", "--short", "HEAD").
305 Return("feature-branch", nil)
307 // First commit succeeds
308 mockGR.EXPECT().
309 Git("log", "-1", "--format=%s", "goodcommit").
310 Return("Good commit", nil)
311 mockGR.EXPECT().
312 Git("checkout", "-b", gomock.Any(), "test-test-stack-existing01").
313 Return("", nil)
314 mockGR.EXPECT().
315 Git("cherry-pick", "goodcommit").
316 Return("", nil)
318 // Second commit conflicts
319 mockGR.EXPECT().
320 Git("log", "-1", "--format=%s", "badcommit").
321 Return("Bad commit", nil)
322 mockGR.EXPECT().
323 Git("checkout", "-b", gomock.Any(), gomock.Any()).
324 Return("", nil)
325 mockGR.EXPECT().
326 Git("cherry-pick", "badcommit").
327 Return("", fmt.Errorf("conflict"))
329 mockGR.EXPECT().
330 Git("cherry-pick", "--abort").
331 Return("", nil)
333 // Rollback: restore branch, delete created branches
334 mockGR.EXPECT().
335 Git("checkout", "feature-branch").
336 Return("", nil).Times(2)
337 mockGR.EXPECT().
338 Git("branch", "-D", gomock.Any()).
339 Return("", nil).Times(2)
341 factory := createFactoryWithConfig("test")
343 existingStack, err := git.GatherStackRefs(stackTitle)
344 require.NoError(t, err)
345 require.Len(t, existingStack.Refs, 1)
347 err = createBranches(factory, mockGR, []string{"goodcommit", "badcommit"}, stackTitle, existingStack)
348 require.Error(t, err)
349 assert.Contains(t, err.Error(), "conflict cherry-picking commit 2/2")
351 // Verify the existing ref's Next pointer was reverted (no dangling pointer)
352 stack, err := git.GatherStackRefs(stackTitle)
353 require.NoError(t, err)
354 assert.Len(t, stack.Refs, 1, "only the original ref should remain")
356 restoredRef := stack.First()
357 assert.Equal(t, "Existing layer", restoredRef.Description)
358 assert.Empty(t, restoredRef.Next, "existing ref's Next should be reverted to empty")
360 _ = dir
361 })
364func TestParseBaseBranch(t *testing.T) {
365 t.Setenv("NO_COLOR", "true")
367 t.Run("resolves branch name from revision range", func(t *testing.T) {
368 ctrl := gomock.NewController(t)
369 mockGR := git_testing.NewMockGitRunner(ctrl)
371 mockGR.EXPECT().
372 Git("rev-parse", "--abbrev-ref", "main").
373 Return("main", nil)
375 branch, err := parseBaseBranch(mockGR, []string{"main..HEAD"})
376 require.NoError(t, err)
377 assert.Equal(t, "main", branch)
378 })
380 t.Run("rejects relative revision like HEAD~3", func(t *testing.T) {
381 ctrl := gomock.NewController(t)
382 mockGR := git_testing.NewMockGitRunner(ctrl)
384 mockGR.EXPECT().
385 Git("rev-parse", "--abbrev-ref", "HEAD~3").
386 Return("HEAD~3", nil)
388 _, err := parseBaseBranch(mockGR, []string{"HEAD~3..HEAD"})
389 require.Error(t, err)
390 assert.Contains(t, err.Error(), "relative revision")
391 assert.Contains(t, err.Error(), "HEAD~3")
392 })
394 t.Run("rejects HEAD^ syntax", func(t *testing.T) {
395 ctrl := gomock.NewController(t)
396 mockGR := git_testing.NewMockGitRunner(ctrl)
398 mockGR.EXPECT().
399 Git("rev-parse", "--abbrev-ref", "HEAD^").
400 Return("HEAD^", nil)
402 _, err := parseBaseBranch(mockGR, []string{"HEAD^..HEAD"})
403 require.Error(t, err)
404 assert.Contains(t, err.Error(), "relative revision")
405 })
407 t.Run("returns empty string when no range provided", func(t *testing.T) {
408 ctrl := gomock.NewController(t)
409 mockGR := git_testing.NewMockGitRunner(ctrl)
411 branch, err := parseBaseBranch(mockGR, []string{"abc123"})
412 require.NoError(t, err)
413 assert.Empty(t, branch)
414 })
416 t.Run("returns error when rev-parse fails", func(t *testing.T) {
417 ctrl := gomock.NewController(t)
418 mockGR := git_testing.NewMockGitRunner(ctrl)
420 mockGR.EXPECT().
421 Git("rev-parse", "--abbrev-ref", "nonexistent").
422 Return("", fmt.Errorf("unknown revision"))
424 _, err := parseBaseBranch(mockGR, []string{"nonexistent..HEAD"})
425 require.Error(t, err)
426 assert.Contains(t, err.Error(), "could not resolve")
427 })
430func TestRunNoTTY(t *testing.T) {
431 t.Setenv("NO_COLOR", "true")
433 t.Run("errors when no stack and no TTY", func(t *testing.T) {
434 git.InitGitRepoWithCommit(t)
436 ctrl := gomock.NewController(t)
437 mockGR := git_testing.NewMockGitRunner(ctrl)
439 mockGR.EXPECT().
440 Git("rev-parse", "--abbrev-ref", "main").
441 Return("main", nil)
443 exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
444 return NewCmdInferStack(f, mockGR)
445 }, false,
446 cmdtest.WithGitLabClient(cmdtest.NewTestApiClient(t, nil, "", "gitlab.com").Lab()),
447 )
449 _, err := exec("main..HEAD --all")
450 require.Error(t, err)
451 assert.Contains(t, err.Error(), "no stack found and no TTY available. Use --name to specify a stack name")
452 })
454 t.Run("errors when not on TTY and --all not specified", func(t *testing.T) {
455 git.InitGitRepoWithCommit(t)
457 stackTitle := "test-stack"
458 require.NoError(t, git.SetCurrentStackTitle(stackTitle))
459 _, err := git.AddStackRefDir(stackTitle)
460 require.NoError(t, err)
461 require.NoError(t, git.AddStackBaseBranch(stackTitle, "main"))
463 ctrl := gomock.NewController(t)
464 mockGR := git_testing.NewMockGitRunner(ctrl)
466 exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
467 return NewCmdInferStack(f, mockGR)
468 }, false,
469 cmdtest.WithGitLabClient(cmdtest.NewTestApiClient(t, nil, "", "gitlab.com").Lab()),
470 )
472 _, err = exec("main..HEAD")
473 require.Error(t, err)
474 assert.Contains(t, err.Error(), "no TTY available: use --all to include all commits in the revision range (glab stack infer --all <revision-range>)")
475 })
477 t.Run("errors before creating stack when no TTY and --all not specified", func(t *testing.T) {
478 git.InitGitRepoWithCommit(t)
480 ctrl := gomock.NewController(t)
481 mockGR := git_testing.NewMockGitRunner(ctrl)
483 exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
484 return NewCmdInferStack(f, mockGR)
485 }, false,
486 cmdtest.WithGitLabClient(cmdtest.NewTestApiClient(t, nil, "", "gitlab.com").Lab()),
487 )
489 _, err := exec("main..HEAD --name new-stack")
490 require.Error(t, err)
491 assert.Contains(t, err.Error(), "no TTY available: use --all to include all commits in the revision range (glab stack infer --all <revision-range>)")
493 _, err = git.GetCurrentStackTitle()
494 require.Error(t, err)
495 })
497 t.Run("succeeds when not on TTY with --all", func(t *testing.T) {
498 git.InitGitRepoWithCommit(t)
500 stackTitle := "test-stack"
501 require.NoError(t, git.SetCurrentStackTitle(stackTitle))
502 _, err := git.AddStackRefDir(stackTitle)
503 require.NoError(t, err)
504 require.NoError(t, git.AddStackBaseBranch(stackTitle, "main"))
506 ctrl := gomock.NewController(t)
507 mockGR := git_testing.NewMockGitRunner(ctrl)
509 mockGR.EXPECT().
510 Git("rev-parse", "--abbrev-ref", "main").
511 Return("main", nil)
513 mockGR.EXPECT().
514 Git("log", "--format=%s%x00%h%x00%an", "--reverse", "main..HEAD").
515 Return("commit 1\x00abc123\x00author\n", nil)
517 mockGR.EXPECT().
518 Git("symbolic-ref", "--quiet", "--short", "HEAD").
519 Return("main", nil)
521 mockGR.EXPECT().
522 Git("log", "-1", "--format=%s", "abc123").
523 Return("commit 1", nil)
525 mockGR.EXPECT().
526 Git("checkout", "-b", gomock.Any(), "main").
527 Return("", nil)
529 mockGR.EXPECT().
530 Git("cherry-pick", "abc123").
531 Return("", nil)
533 mockGR.EXPECT().
534 Git("checkout", "main").
535 Return("", nil)
537 exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
538 return NewCmdInferStack(f, mockGR)
539 }, false,
540 cmdtest.WithGitLabClient(cmdtest.NewTestApiClient(t, nil, "", "gitlab.com").Lab()),
541 )
543 _, err = exec("main..HEAD --all")
544 require.NoError(t, err)
545 })
548func createFactoryWithConfig(value string) cmdutils.Factory {
549 strconfig := heredoc.Doc(`
550 branch_prefix: ` + value + `
551 `)
553 cfg := config.NewFromString(strconfig)
554 ios, _, _, _ := cmdtest.TestIOStreams()
556 return cmdtest.NewTestFactory(ios, cmdtest.WithConfig(cfg))
559func fixedTime() time.Time {
560 return time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC)
Diagnostics8 git calls · 215 ms
CallStatusSizeTime0215 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 · 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: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:0200432 B · 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=432
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=ff2d1e7abc74964e5679ebdb51f1ac0d0dc3aff0
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=432
git.pkt.payload.max=405
git.sideband.band1.bytes=405
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=405
git.pack.trailer=8f3029a269217d94d12d0671e0490fe3d5506303
Open pack map
fetchtree:0200199 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=199
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=8109696a12928135171f031112e487158b02c470
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=199
git.pkt.payload.max=172
git.sideband.band1.bytes=172
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=172
git.pack.trailer=7619d11a8f208890971c50dea8f51b0e072e21b9
Open pack map
fetch2002.6 KiB202 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=202
git.response.bytes=2654
git.response.cache=MISS
git.response.duration_ms=202
git.fetch.wants=c2ae905f6af582e8cc93e48878be8a7b767b3189
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=2654
git.pkt.payload.max=2627
git.sideband.band1.bytes=2627
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
a5e2429fa965cf56
Request
b586b949…
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