GitLabgitlab-org

cli

main
ply7 git calls46 ms101 KiB5 cachedprotocol v2
548 lines15 KiBRaw
1//go:build !integration
3package update
5import (
6 "errors"
7 "fmt"
8 "net"
9 "net/http"
10 "os"
11 "path/filepath"
12 "testing"
13 "time"
15 "github.com/spf13/cobra"
16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
18 "go.uber.org/mock/gomock"
20 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
21 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
23 "gitlab.com/gitlab-org/cli/internal/api"
24 "gitlab.com/gitlab-org/cli/internal/cmdutils"
25 "gitlab.com/gitlab-org/cli/internal/commands/skills/installed"
26 "gitlab.com/gitlab-org/cli/internal/config"
27 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
30// mockClientCreator sets up the clientCreator with a test client and returns a cleanup function.
31func mockClientCreator(t *testing.T, testClient *gitlabtesting.TestClient) {
32 t.Helper()
33 oldCreator := clientCreator
34 clientCreator = func(userAgent string, options ...api.ClientOption) (*api.Client, error) {
35 return api.NewClient(
36 func(*http.Client) (gitlab.AuthSource, error) {
37 return gitlab.AccessTokenAuthSource{Token: ""}, nil
38 },
39 api.WithGitLabClient(testClient.Client),
40 )
41 }
42 t.Cleanup(func() {
43 clientCreator = oldCreator
44 })
47// stubInstallMethod swaps the package-level install-method detector so tests
48// don't depend on the filesystem path of the running test binary.
49func stubInstallMethod(t *testing.T, method InstallMethod) {
50 t.Helper()
51 old := installMethodDetector
52 installMethodDetector = func() InstallMethod { return method }
53 t.Cleanup(func() { installMethodDetector = old })
56// stubNoInstalledSkills swaps the package-level skill discoverer so tests
57// don't depend on whatever the developer has under ~/.agents/skills/.
58func stubNoInstalledSkills(t *testing.T) {
59 t.Helper()
60 old := discoverInstalled
61 discoverInstalled = func() ([]installed.Skill, error) { return nil, nil }
62 t.Cleanup(func() { discoverInstalled = old })
65func TestNewCheckUpdateCmd(t *testing.T) {
66 // NOTE: we need to force disable colors, otherwise we'd need ANSI sequences in our test output assertions.
67 t.Setenv("NO_COLOR", "true")
69 tests := []struct {
70 name string
71 version string
72 codingAgent string
73 installMethod InstallMethod
74 stdErr string
75 }{
76 {
77 name: "same version",
78 version: "v1.11.1",
79 stdErr: "You are using the latest version of glab\n",
80 },
81 {
82 name: "older version, human, homebrew",
83 version: "v1.11.0",
84 installMethod: InstallMethod{Name: installMethodHomebrew, UpgradeCommand: homebrewUpgradeCommand},
85 stdErr: "\nA new version of glab is available\n" +
86 " v1.11.0 → v1.11.1\n" +
87 " Run: brew upgrade glab\n" +
88 " Release notes: https://gitlab.com/gitlab-org/cli/-/releases/v1.11.1\n",
89 },
90 {
91 name: "older version, human, unknown install method",
92 version: "v1.11.0",
93 installMethod: InstallMethod{Name: installMethodUnknown},
94 stdErr: "\nA new version of glab is available\n" +
95 " v1.11.0 → v1.11.1\n" +
96 " Release notes: https://gitlab.com/gitlab-org/cli/-/releases/v1.11.1\n",
97 },
98 {
99 name: "older version, agent, homebrew",
100 version: "v1.11.0",
101 codingAgent: "claude-code",
102 installMethod: InstallMethod{Name: installMethodHomebrew, UpgradeCommand: homebrewUpgradeCommand},
103 stdErr: "[glab] Update available: v1.11.0 → v1.11.1 (installed via homebrew). Suggested upgrade command: `brew upgrade glab`. Release notes: https://gitlab.com/gitlab-org/cli/-/releases/v1.11.1\n",
104 },
105 {
106 name: "older version, agent, unknown install method",
107 version: "v1.11.0",
108 codingAgent: "claude-code",
109 installMethod: InstallMethod{Name: installMethodUnknown},
110 stdErr: "[glab] Update available: v1.11.0 → v1.11.1. Release notes: https://gitlab.com/gitlab-org/cli/-/releases/v1.11.1\n",
111 },
112 }
113 for _, tc := range tests {
114 t.Run(tc.name, func(t *testing.T) {
115 testClient := gitlabtesting.NewTestClient(t)
117 // Mock ListReleases
118 testClient.MockReleases.EXPECT().
119 ListReleases("gitlab-org/cli", gomock.Any()).
120 DoAndReturn(func(pid any, opts *gitlab.ListReleasesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Release, *gitlab.Response, error) {
121 // Verify pagination options
122 assert.Equal(t, int64(1), opts.Page)
123 assert.Equal(t, int64(1), opts.PerPage)
124 return []*gitlab.Release{
125 {
126 TagName: "v1.11.1",
127 Name: "v1.11.1",
128 ReleasedAt: new(time.Date(2020, 11, 3, 5, 39, 4, 0, time.UTC)),
129 },
130 }, nil, nil
131 })
133 mockClientCreator(t, testClient)
134 stubInstallMethod(t, tc.installMethod)
135 stubNoInstalledSkills(t)
137 exec := cmdtest.SetupCmdForTest(t, NewCheckUpdateCmd, true,
138 cmdtest.WithBuildInfo(api.BuildInfo{Version: tc.version, CodingAgent: tc.codingAgent}),
139 )
140 output, err := exec("")
142 require.NoError(t, err)
143 assert.Empty(t, output.String())
144 assert.Equal(t, tc.stdErr, output.Stderr())
145 })
146 }
149func TestNewCheckUpdateCmd_error(t *testing.T) {
150 testClient := gitlabtesting.NewTestClient(t)
152 // Mock ListReleases - returns 404
153 notFoundResp := &gitlab.Response{
154 Response: &http.Response{StatusCode: http.StatusNotFound},
155 }
156 testClient.MockReleases.EXPECT().
157 ListReleases("gitlab-org/cli", gomock.Any()).
158 Return(nil, notFoundResp, errors.New("404 Not Found"))
160 mockClientCreator(t, testClient)
162 exec := cmdtest.SetupCmdForTest(t, NewCheckUpdateCmd, true,
163 cmdtest.WithBuildInfo(api.BuildInfo{Version: "1.11.0"}),
164 )
165 output, err := exec("")
167 require.Error(t, err)
168 assert.Equal(t, `failed checking for glab updates: 404 Not Found`, err.Error())
169 assert.Empty(t, output.String())
170 assert.Empty(t, output.Stderr())
173func TestCheckUpdate_GitLabDown(t *testing.T) {
174 testClient := gitlabtesting.NewTestClient(t)
176 // gitlab.com answers with its HTML maintenance page during an incident, which the
177 // API client hands back verbatim inside the error.
178 htmlPage := "<!DOCTYPE html>\n<html>\n<head><title>503 Server Unavailable</title></head><body>...</body></html>"
179 errResp := &gitlab.ErrorResponse{
180 StatusCode: http.StatusServiceUnavailable,
181 Message: "failed to parse unknown error format: " + htmlPage,
182 Response: &http.Response{StatusCode: http.StatusServiceUnavailable},
183 }
184 testClient.MockReleases.EXPECT().
185 ListReleases("gitlab-org/cli", gomock.Any()).
186 Return(nil, &gitlab.Response{Response: errResp.Response}, errResp)
188 mockClientCreator(t, testClient)
190 exec := cmdtest.SetupCmdForTest(t, NewCheckUpdateCmd, true,
191 cmdtest.WithBuildInfo(api.BuildInfo{Version: "1.11.0"}),
192 )
193 output, err := exec("")
195 require.Error(t, err)
196 assert.Equal(t, "failed checking for glab updates: gitlab.com responded with HTTP 503", err.Error())
197 assert.NotContains(t, err.Error(), "<html>")
198 assert.Empty(t, output.String())
199 assert.Empty(t, output.Stderr())
202func TestNewCheckUpdateCmd_no_release(t *testing.T) {
203 testClient := gitlabtesting.NewTestClient(t)
205 // Mock ListReleases - returns empty list
206 testClient.MockReleases.EXPECT().
207 ListReleases("gitlab-org/cli", gomock.Any()).
208 Return([]*gitlab.Release{}, nil, nil)
210 mockClientCreator(t, testClient)
212 exec := cmdtest.SetupCmdForTest(t, NewCheckUpdateCmd, true,
213 cmdtest.WithBuildInfo(api.BuildInfo{Version: "1.11.0"}),
214 )
215 output, err := exec("")
217 require.Error(t, err)
218 assert.Equal(t, "no release found for glab", err.Error())
219 assert.Empty(t, output.String())
220 assert.Empty(t, output.Stderr())
223func Test_isOlderVersion(t *testing.T) {
224 type args struct {
225 latestVersion string
226 currentVersion string
227 }
228 tests := []struct {
229 name string
230 args args
231 want bool
232 }{
233 {
234 name: "latest is newer",
235 args: args{"v1.10.0", "v1.9.1"},
236 want: true,
237 },
238 {
239 name: "latest is current",
240 args: args{"v1.9.2", "v1.9.2"},
241 want: false,
242 },
243 {
244 name: "latest is older",
245 args: args{"v1.9.0", "v1.9.2-pre.1"},
246 want: false,
247 },
248 {
249 name: "current is prerelease",
250 args: args{"v1.9.0", "v1.9.0-pre.1"},
251 want: true,
252 },
253 {
254 name: "latest is older (against prerelease)",
255 args: args{"v1.9.0", "v1.10.0-pre.1"},
256 want: false,
257 },
258 }
259 for _, tt := range tests {
260 t.Run(tt.name, func(t *testing.T) {
261 if got := isOlderVersion(tt.args.latestVersion, tt.args.currentVersion); got != tt.want {
262 t.Errorf("isOlderVersion(%s, %s) = %v, want %v",
263 tt.args.latestVersion, tt.args.currentVersion, got, tt.want)
264 }
265 })
266 }
269func TestShouldSkipUpdate_NoRun(t *testing.T) {
270 tests := []struct {
271 name string
272 previousCommand string
273 }{
274 {
275 name: "when previous command is check-update",
276 previousCommand: "check-update",
277 },
278 {
279 name: "when previous command is an alias for check-update",
280 previousCommand: "update",
281 },
282 {
283 name: "when previous command is completion",
284 previousCommand: "completion",
285 },
286 {
287 name: "when previous command is git-credential",
288 previousCommand: "git-credential",
289 },
290 {
291 name: "when previous command is version",
292 previousCommand: "version",
293 },
294 {
295 name: "when previous command is -v",
296 previousCommand: "-v",
297 },
298 {
299 name: "when previous command is --version",
300 previousCommand: "--version",
301 },
302 }
303 for _, tt := range tests {
304 t.Run(tt.name, func(t *testing.T) {
305 assert.True(t, ShouldSkipUpdate(tt.previousCommand))
306 })
307 }
310func Test_isEnvForcingUpdate(t *testing.T) {
311 tests := []struct {
312 name string
313 envVarKey string
314 envVarVal string
315 forceUpdate bool
316 }{
317 {
318 name: "when the GLAB_CHECK_UPDATE value is true",
319 envVarKey: "GLAB_CHECK_UPDATE",
320 envVarVal: "true",
321 forceUpdate: true,
322 },
323 {
324 name: "when the GLAB_CHECK_UPDATE value is yes",
325 envVarKey: "GLAB_CHECK_UPDATE",
326 envVarVal: "yes",
327 forceUpdate: true,
328 },
329 {
330 name: "when the GLAB_CHECK_UPDATE value is 1",
331 envVarKey: "GLAB_CHECK_UPDATE",
332 envVarVal: "1",
333 forceUpdate: true,
334 },
335 {
336 name: "when GLAB_CHECK_UPDATE is not set",
337 forceUpdate: false,
338 },
339 {
340 name: "when the GLAB_CHECK_UPDATE value is false",
341 envVarKey: "GLAB_CHECK_UPDATE",
342 envVarVal: "false",
343 forceUpdate: false,
344 },
345 {
346 name: "when the GLAB_CHECK_UPDATE value is not a valid option",
347 envVarKey: "GLAB_CHECK_UPDATE",
348 envVarVal: "value-not-supported",
349 forceUpdate: false,
350 },
351 }
352 for _, tt := range tests {
353 t.Run(tt.name, func(t *testing.T) {
354 if tt.envVarKey != "" {
355 t.Setenv(tt.envVarKey, tt.envVarVal)
356 }
358 assert.Equal(t, tt.forceUpdate, isEnvForcingUpdate())
359 })
360 }
363func Test_checkLastUpdate(t *testing.T) {
364 tests := []struct {
365 name string
366 lastUpdate string
367 expectedResult bool
368 expectError bool
369 envVarKey string
370 envVarVal string
371 }{
372 {
373 name: "first time check",
374 lastUpdate: "",
375 expectedResult: true,
376 expectError: false,
377 },
378 {
379 name: "should skip if we checked within the last 24h",
380 lastUpdate: time.Now().Add(-12 * time.Hour).Format(time.RFC3339), // 12h ago
381 expectedResult: false,
382 expectError: false,
383 },
384 {
385 name: "should not skip if we checked more than 24h ago",
386 lastUpdate: time.Now().Add(-48 * time.Hour).Format(time.RFC3339), // 2 days ago
387 expectedResult: true,
388 expectError: false,
389 },
390 {
391 name: "should return error due to invalid timestamp format",
392 lastUpdate: "invalid-timestamp",
393 expectedResult: false,
394 expectError: true,
395 },
396 {
397 name: "should not skip because of GLAB_CHECK_UPDATE=true and last check was 12h ago",
398 lastUpdate: time.Now().Add(-12 * time.Hour).Format(time.RFC3339), // 12h ago
399 envVarKey: "GLAB_CHECK_UPDATE",
400 envVarVal: "true",
401 expectedResult: true,
402 expectError: false,
403 },
404 {
405 name: "should not skip because of GLAB_CHECK_UPDATE=true and last check was 2 days ago",
406 lastUpdate: time.Now().Add(-48 * time.Hour).Format(time.RFC3339), // 2 days ago
407 envVarKey: "GLAB_CHECK_UPDATE",
408 envVarVal: "true",
409 expectedResult: true,
410 expectError: false,
411 },
412 {
413 name: "should not skip because of GLAB_CHECK_UPDATE=false and last check was 12h ago",
414 lastUpdate: time.Now().Add(-12 * time.Hour).Format(time.RFC3339), // 12h ago
415 envVarKey: "GLAB_CHECK_UPDATE",
416 envVarVal: "false",
417 expectedResult: false,
418 expectError: false,
419 },
420 {
421 name: "should not skip because of GLAB_CHECK_UPDATE=false and last check was 2 days ago",
422 lastUpdate: time.Now().Add(-48 * time.Hour).Format(time.RFC3339), // 2 days ago
423 envVarKey: "GLAB_CHECK_UPDATE",
424 envVarVal: "false",
425 expectedResult: true,
426 expectError: false,
427 },
428 }
430 for _, tt := range tests {
431 t.Run(tt.name, func(t *testing.T) {
432 if tt.envVarKey != "" {
433 t.Setenv(tt.envVarKey, tt.envVarVal)
434 }
436 dir := t.TempDir()
437 f := cmdtest.NewTestFactory(nil,
438 func(f *cmdtest.Factory) {
439 f.ConfigStub = func() config.Config {
440 if tt.lastUpdate != "" {
441 return config.NewFromStringInDir(fmt.Sprintf("last_update_check_timestamp: %s", tt.lastUpdate), dir)
442 }
443 return config.NewBlankConfigInDir(dir)
444 }
445 },
446 )
448 result, err := checkLastUpdate(f, false)
450 if tt.expectError {
451 require.Error(t, err)
452 } else {
453 require.NoError(t, err)
454 assert.Equal(t, tt.expectedResult, result)
455 }
457 // For first time check, verify timestamp was set
458 if tt.name == "first time check" {
459 data, err := os.ReadFile(filepath.Join(dir, "config.yml"))
460 require.NoError(t, err)
461 cfg := config.NewFromString(string(data))
462 timestamp, err := cfg.Get("", "last_update_check_timestamp")
464 require.NoError(t, err)
465 assert.NotEmpty(t, timestamp)
467 // Verify the timestamp is in correct format
468 _, err = time.Parse(time.RFC3339, timestamp)
469 assert.NoError(t, err)
470 }
471 })
472 }
475func TestPrintUpdateError(t *testing.T) {
476 cmd := &cobra.Command{}
478 type args struct {
479 err error
480 cmd *cobra.Command
481 debug bool
482 }
483 tests := []struct {
484 name string
485 args args
486 wantOut string
487 }{
488 {
489 name: "generic error",
490 args: args{
491 err: errors.New("the app exploded"),
492 cmd: cmd,
493 debug: false,
494 },
495 wantOut: "ERROR: the app exploded\n\n",
496 },
497 {
498 name: "DNS error",
499 args: args{
500 err: fmt.Errorf("DNS error: %w", &net.DNSError{
501 Name: "https://gitlab.com/api/v4",
502 }),
503 cmd: cmd,
504 debug: false,
505 },
506 wantOut: "x error connecting to https://gitlab.com/api/v4\n\n",
507 },
508 {
509 name: "DNS error with debug",
510 args: args{
511 err: fmt.Errorf("DNS error: %w", &net.DNSError{
512 Name: "https://gitlab.com/api/v4",
513 }),
514 cmd: cmd,
515 debug: true,
516 },
517 wantOut: "x error connecting to https://gitlab.com/api/v4\nx lookup https://gitlab.com/api/v4: \n\n",
518 },
519 {
520 name: "Cobra flag error",
521 args: args{
522 err: &cmdutils.FlagError{Err: errors.New("unknown flag --foo")},
523 cmd: cmd,
524 debug: false,
525 },
526 wantOut: "ERROR: unknown flag --foo\n\n",
527 },
528 {
529 name: "unknown Cobra command error",
530 args: args{
531 err: errors.New("unknown command foo"),
532 cmd: cmd,
533 debug: false,
534 },
535 wantOut: "ERROR: unknown command foo\n\n",
536 },
537 }
539 for _, tt := range tests {
540 t.Run(tt.name, func(t *testing.T) {
541 streams, _, _, out := cmdtest.TestIOStreams()
542 PrintUpdateError(streams, tt.args.err, tt.args.cmd, tt.args.debug)
543 if gotOut := out.String(); gotOut != tt.wantOut {
544 t.Errorf("PrintUpdateError() = %q, want %q", gotOut, tt.wantOut)
545 }
546 })
547 }
Diagnostics7 git calls · 46 ms
CallStatusSizeTime046 ms
discover200185 B4 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
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 KiB3 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=UPDATING
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
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=4
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
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=4
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:02001.8 KiB · hit4 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=1857
git.response.cache=HIT
git.response.duration_ms=4
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:0200329 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=30
git.response.bytes=329
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=8b36f3db012b2c3ab0120649b10a85336c3bf03e
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=329
git.pkt.payload.max=302
git.sideband.band1.bytes=302
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=302
git.pack.trailer=616b294f8a6e9b6163f51633333a4ad7b16f0d98
Open pack map
fetch2003.7 KiB · hit31 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3807
git.response.cache=HIT
git.response.duration_ms=31
git.fetch.wants=03543c47fb97f651f7974999004d3f642ecb2eda
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=3807
git.pkt.payload.max=3780
git.sideband.band1.bytes=3780
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
a5e288ddeabd4af4
Request
8d4d2f0d…
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