GitLabgitlab-org

cli

main
ply9 git calls225 ms102 KiB7 cachedprotocol v2
512 lines20 KiBRaw
1//go:build !integration
3package start
5import (
6 "encoding/base64"
7 "encoding/json"
8 "net/http"
9 "net/http/httptest"
10 "os"
11 "regexp"
12 "strconv"
13 "strings"
14 "testing"
16 "github.com/google/uuid"
17 "github.com/stretchr/testify/assert"
18 "github.com/stretchr/testify/require"
19 autoflowrpcv1 "gitlab.com/gitlab-org/protos/gen/go/gitlab/autoflow/rpc/v1"
20 autoflowv1 "gitlab.com/gitlab-org/protos/gen/go/gitlab/autoflow/v1"
21 "go.uber.org/mock/gomock"
22 "google.golang.org/grpc/codes"
23 "google.golang.org/grpc/status"
24 "google.golang.org/protobuf/proto"
26 "gitlab.com/gitlab-org/cli/internal/testing/autoflowtest"
27 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
28 "gitlab.com/gitlab-org/cli/internal/testing/tokenexchangetest"
31type startCall = autoflowtest.Call[*autoflowrpcv1.StartWorkflowRequest]
33func expectStart(relay *autoflowtest.Relay, resp *autoflowrpcv1.StartWorkflowResponse, err error) <-chan startCall {
34 calls := make(chan startCall, 1)
35 relay.Mock.EXPECT().StartWorkflow(gomock.Any(), gomock.Any()).DoAndReturn(autoflowtest.Answer(calls, resp, err))
36 return calls
39var startedResponse = &autoflowrpcv1.StartWorkflowResponse{WorkflowKey: "wf-key", WorkflowToken: "wf-token"}
41func newTestExec(t *testing.T, srv *httptest.Server, opts ...cmdtest.FactoryOption) cmdtest.CmdExecFunc {
42 t.Helper()
43 return tokenexchangetest.NewTestExec(t, srv, NewCmd, opts...)
46func TestStart_Text(t *testing.T) {
47 t.Parallel()
49 relay := autoflowtest.NewRelay(t)
50 calls := expectStart(relay, startedResponse, nil)
51 var gotBody tokenexchangetest.WireRequest
52 srv, count, token := autoflowtest.NewTokenServer(t, &gotBody)
53 exec := newTestExec(t, srv)
55 out, err := exec(relay.Args() + " --script-file " + autoflowtest.WriteFile(t, "def main(): return 1\n"))
56 require.NoError(t, err)
58 assert.EqualValues(t, 1, count.Load())
59 assert.Equal(t, tokenexchangetest.WireRequest{Audience: "gitlab-autoflow", ExpiresIn: 60}, gotBody)
61 call := autoflowtest.Received(t, calls)
62 gotReq := call.Req
63 assert.Equal(t, []string{"Bearer " + token}, call.Auth)
64 assert.Equal(t, []byte("def main(): return 1\n"), gotReq.GetWorkflowDefinition())
65 wantNamespace := uuid.MustParse(autoflowtest.NamespaceID)
66 assert.Equal(t, wantNamespace[:], gotReq.GetNamespaceId())
67 assert.Len(t, gotReq.GetTokenBinding(), 64)
68 assert.True(t, strings.HasPrefix(gotReq.GetIdempotencyKey(), "glab-"), gotReq.GetIdempotencyKey())
70 assert.Equal(t, "workflow_key: wf-key\n"+
71 "workflow_token: wf-token\n"+
72 "namespace_id: "+autoflowtest.NamespaceID+"\n"+
73 "idempotency_key: "+gotReq.GetIdempotencyKey()+"\n"+
74 "token_binding: "+base64.StdEncoding.EncodeToString(gotReq.GetTokenBinding())+"\n",
75 out.OutBuf.String())
76 assert.Empty(t, out.ErrBuf.String())
79func TestStart_JSONWithIdempotencyKey(t *testing.T) {
80 t.Parallel()
82 relay := autoflowtest.NewRelay(t)
83 calls := expectStart(relay, startedResponse, nil)
84 var gotBody tokenexchangetest.WireRequest
85 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
86 exec := newTestExec(t, srv)
88 out, err := exec(relay.Args() + ` --script 'def main(): return 1' --idempotency-key my-key --output json`)
89 require.NoError(t, err)
91 gotReq := autoflowtest.Received(t, calls).Req
92 assert.Equal(t, "my-key", gotReq.GetIdempotencyKey())
93 assert.Equal(t, []byte("def main(): return 1"), gotReq.GetWorkflowDefinition())
95 var got struct {
96 WorkflowKey string `json:"workflow_key"`
97 WorkflowToken string `json:"workflow_token"`
98 NamespaceID string `json:"namespace_id"`
99 IdempotencyKey string `json:"idempotency_key"`
100 TokenBinding string `json:"token_binding"`
101 }
102 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &got))
103 assert.Equal(t, "wf-key", got.WorkflowKey)
104 assert.Equal(t, "wf-token", got.WorkflowToken)
105 assert.Equal(t, autoflowtest.NamespaceID, got.NamespaceID)
106 assert.Equal(t, "my-key", got.IdempotencyKey)
107 assert.Equal(t, base64.StdEncoding.EncodeToString(gotReq.GetTokenBinding()), got.TokenBinding)
110func TestStart_ScriptFromStdin(t *testing.T) {
111 t.Parallel()
113 relay := autoflowtest.NewRelay(t)
114 calls := expectStart(relay, startedResponse, nil)
115 var gotBody tokenexchangetest.WireRequest
116 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
117 exec := newTestExec(t, srv, cmdtest.WithStdin("def main(): return 2\n"))
119 _, err := exec(relay.Args() + " --script-file -")
120 require.NoError(t, err)
122 gotReq := autoflowtest.Received(t, calls).Req
123 assert.Equal(t, []byte("def main(): return 2\n"), gotReq.GetWorkflowDefinition())
126func TestStart_FlagErrors(t *testing.T) {
127 t.Parallel()
129 relay := autoflowtest.NewRelay(t)
130 tests := []struct {
131 name string
132 args string
133 wantErr string
134 }{
135 {
136 name: "no script",
137 args: relay.Args(),
138 wantErr: "at least one of the flags in the group [script script-file] is required",
139 },
140 {
141 name: "script and script file",
142 args: relay.Args() + " --script x --script-file y",
143 wantErr: "if any flags in the group [script script-file] are set none of the others can be",
144 },
145 {
146 name: "no address",
147 args: "--namespace-id " + autoflowtest.NamespaceID + " --script x",
148 wantErr: `required flag(s) "address" not set`,
149 },
150 {
151 name: "invalid namespace ID",
152 args: "--address " + relay.Address + " --namespace-id 42 --script x",
153 wantErr: "error parsing --namespace-id",
154 },
155 {
156 name: "nil namespace ID",
157 args: "--address " + relay.Address + " --namespace-id 00000000-0000-0000-0000-000000000000 --script x",
158 wantErr: "must not be the nil UUID",
159 },
160 {
161 name: "token binding not base64",
162 args: relay.Args() + " --script x --idempotency-key k --token-binding-file " + autoflowtest.WriteFile(t, "!!"),
163 wantErr: "error parsing the token binding",
164 },
165 {
166 name: "token binding too short",
167 args: relay.Args() + " --script x --idempotency-key k --token-binding-file " + autoflowtest.WriteFile(t, base64.StdEncoding.EncodeToString(make([]byte, 63))),
168 wantErr: "must decode to 64 bytes, got 63",
169 },
170 {
171 name: "token binding without idempotency key",
172 args: relay.Args() + " --script x --token-binding-file " + autoflowtest.WriteFile(t, base64.StdEncoding.EncodeToString(make([]byte, 64))),
173 wantErr: "a token binding re-submits an earlier workflow, so it needs the --idempotency-key of that workflow",
174 },
175 {
176 name: "script and token binding from stdin",
177 args: relay.Args() + " --script-file - --token-binding-file -",
178 wantErr: "only one of --script-file and --token-binding-file can read from standard input",
179 },
180 {
181 name: "empty script",
182 args: relay.Args() + " --script ''",
183 wantErr: "the workflow definition is empty",
184 },
185 {
186 name: "missing script file",
187 args: relay.Args() + " --script-file /nonexistent/main.star",
188 wantErr: "failed to read the workflow definition",
189 },
190 {
191 name: "invalid hostname",
192 args: relay.Args() + " --script x --hostname https://gitlab.example.com",
193 wantErr: "error parsing --hostname",
194 },
195 }
197 for _, tc := range tests {
198 t.Run(tc.name, func(t *testing.T) {
199 t.Parallel()
201 var gotBody tokenexchangetest.WireRequest
202 srv, count, _ := autoflowtest.NewTokenServer(t, &gotBody)
203 exec := newTestExec(t, srv)
205 _, err := exec(tc.args)
206 require.Error(t, err)
207 assert.Contains(t, err.Error(), tc.wantErr)
208 assert.EqualValues(t, 0, count.Load())
209 })
210 }
213func TestStart_AudienceNotEnabled(t *testing.T) {
214 t.Parallel()
216 relay := autoflowtest.NewRelay(t)
217 srv, count := tokenexchangetest.NewTestServer(t, func(w http.ResponseWriter, r *http.Request) {
218 w.Header().Set("Content-Type", "application/json")
219 w.WriteHeader(http.StatusBadRequest)
220 _, _ = w.Write([]byte(`{"error":"audience does not have a valid value"}`))
221 })
222 exec := newTestExec(t, srv)
224 _, err := exec(relay.Args() + " --script x")
225 require.Error(t, err)
226 assert.Contains(t, err.Error(), "audience does not have a valid value")
227 assert.Contains(t, err.Error(), "token_exchange_autoflow_audience feature flag")
228 assert.EqualValues(t, 1, count.Load())
231// The test sets TMPDIR, where the command saves a generated binding, so it
232// cannot run in parallel.
233func TestStart_RelayErrorSavesGeneratedBinding(t *testing.T) {
234 t.Setenv("TMPDIR", t.TempDir())
235 relay := autoflowtest.NewRelay(t)
236 calls := expectStart(relay, nil, status.Error(codes.DeadlineExceeded, "context deadline exceeded"))
237 var gotBody tokenexchangetest.WireRequest
238 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
239 exec := newTestExec(t, srv)
241 out, err := exec(relay.Args() + " --script x")
242 require.Error(t, err)
243 assert.Equal(t, codes.DeadlineExceeded, status.Code(err))
244 assert.Empty(t, out.OutBuf.String())
245 gotReq := autoflowtest.Received(t, calls).Req
246 m := regexp.MustCompile(`^failed to start workflow \(to retry without starting a second one, pass --idempotency-key (\S+) and --token-binding-file "([^"]+)"\): `).FindStringSubmatch(err.Error())
247 require.NotNil(t, m, err.Error())
248 assert.Equal(t, gotReq.GetIdempotencyKey(), m[1])
249 info, err := os.Stat(m[2])
250 require.NoError(t, err)
251 assert.Equal(t, os.FileMode(0o600), info.Mode().Perm())
253 // The hint is the retry.
254 retries := expectStart(relay, startedResponse, nil)
255 _, err = exec(relay.Args() + " --script x --idempotency-key " + m[1] + " --token-binding-file " + m[2])
256 require.NoError(t, err)
257 retry := autoflowtest.Received(t, retries).Req
258 assert.Equal(t, gotReq.GetIdempotencyKey(), retry.GetIdempotencyKey())
259 assert.Equal(t, gotReq.GetTokenBinding(), retry.GetTokenBinding())
262// The test sets TMPDIR, where the command would save a generated binding, so
263// it cannot run in parallel.
264func TestStart_RelayRejectionHasNoRetryHint(t *testing.T) {
265 for _, code := range []codes.Code{codes.Unauthenticated, codes.PermissionDenied, codes.InvalidArgument, codes.FailedPrecondition, codes.ResourceExhausted} {
266 t.Run(code.String(), func(t *testing.T) {
267 tmp := t.TempDir()
268 t.Setenv("TMPDIR", tmp)
269 relay := autoflowtest.NewRelay(t)
270 expectStart(relay, nil, status.Error(code, "rejected"))
271 var gotBody tokenexchangetest.WireRequest
272 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
273 exec := newTestExec(t, srv)
275 _, err := exec(relay.Args() + " --script x")
276 require.Error(t, err)
277 assert.Equal(t, code, status.Code(err))
278 assert.True(t, strings.HasPrefix(err.Error(), "failed to start workflow: "), err.Error())
279 saved, err := os.ReadDir(tmp)
280 require.NoError(t, err)
281 assert.Empty(t, saved, "a rejected workflow leaves no binding behind")
282 })
283 }
286func TestStart_RelayErrorNamesBindingSource(t *testing.T) {
287 encoded := base64.StdEncoding.EncodeToString(make([]byte, 64))
288 bindingFile := autoflowtest.WriteFile(t, encoded)
290 t.Run("file", func(t *testing.T) {
291 t.Setenv("TMPDIR", t.TempDir())
292 relay := autoflowtest.NewRelay(t)
293 expectStart(relay, nil, status.Error(codes.Unavailable, "connection reset"))
294 var gotBody tokenexchangetest.WireRequest
295 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
296 exec := newTestExec(t, srv)
298 _, err := exec(relay.Args() + " --script x --idempotency-key my-key --token-binding-file " + bindingFile)
299 require.Error(t, err)
300 assert.Contains(t, err.Error(), "pass --idempotency-key my-key and --token-binding-file "+strconv.Quote(bindingFile)+"): ")
301 saved, err := os.ReadDir(os.Getenv("TMPDIR"))
302 require.NoError(t, err)
303 assert.Empty(t, saved, "a binding from a file is not copied")
304 })
306 t.Run("environment", func(t *testing.T) {
307 t.Setenv("GLAB_AUTOFLOW_TOKEN_BINDING", encoded)
308 relay := autoflowtest.NewRelay(t)
309 expectStart(relay, nil, status.Error(codes.Unavailable, "connection reset"))
310 var gotBody tokenexchangetest.WireRequest
311 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
312 exec := newTestExec(t, srv)
314 _, err := exec(relay.Args() + " --script x --idempotency-key my-key")
315 require.Error(t, err)
316 assert.Contains(t, err.Error(), "pass --idempotency-key my-key and keep GLAB_AUTOFLOW_TOKEN_BINDING set): ")
317 })
320// The failed handshake is Unavailable, so the command saves the generated
321// binding to TMPDIR, which the test sets and so cannot run in parallel.
322func TestStart_UntrustedCertificate(t *testing.T) {
323 t.Setenv("TMPDIR", t.TempDir())
324 relay := autoflowtest.NewRelay(t)
325 var gotBody tokenexchangetest.WireRequest
326 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
327 exec := newTestExec(t, srv)
329 _, err := exec("--address " + relay.Address + " --namespace-id " + autoflowtest.NamespaceID + " --script x")
330 require.Error(t, err)
331 assert.Equal(t, codes.Unavailable, status.Code(err))
332 assert.Contains(t, err.Error(), "certificate")
335func TestStart_InvalidCACert(t *testing.T) {
336 t.Parallel()
338 relay := autoflowtest.NewRelay(t)
339 var gotBody tokenexchangetest.WireRequest
340 srv, count, _ := autoflowtest.NewTokenServer(t, &gotBody)
341 exec := newTestExec(t, srv)
343 _, err := exec("--address " + relay.Address + " --namespace-id " + autoflowtest.NamespaceID + " --script x --ca-cert " + autoflowtest.WriteFile(t, "not a certificate"))
344 require.Error(t, err)
345 assert.Contains(t, err.Error(), "contains no PEM-encoded certificate")
346 assert.EqualValues(t, 0, count.Load())
349func TestStart_NamespaceOverride(t *testing.T) {
350 t.Parallel()
352 relay := autoflowtest.NewRelay(t)
353 calls := expectStart(relay, startedResponse, nil)
354 var gotBody tokenexchangetest.WireRequest
355 // The token carries no organization: an explicit namespace does not need one.
356 srv, _ := tokenexchangetest.NewTokenExchangeServer(t, autoflowtest.MakeToken(t, nil), &gotBody)
357 exec := newTestExec(t, srv)
358 other := uuid.New()
360 out, err := exec(relay.Args() + " --script x --namespace-id " + other.String())
361 require.NoError(t, err)
362 assert.Equal(t, other[:], autoflowtest.Received(t, calls).Req.GetNamespaceId())
363 assert.Contains(t, out.OutBuf.String(), "namespace_id: "+other.String()+"\n")
366func TestStart_TokenWithoutOrganization(t *testing.T) {
367 t.Parallel()
369 tests := []struct {
370 name string
371 claims map[string]any
372 wantErr string
373 }{
374 {name: "no gitlab claims", claims: nil, wantErr: `the AutoFlow token is not issued for an organization (its gitlab.origin claim is "")`},
375 {name: "origin ID not a UUID", claims: map[string]any{"origin": "organization", "origin_id": "42"}, wantErr: `the gitlab.origin_id claim of the AutoFlow token is "42", not an organization UUID`},
376 {name: "nil origin ID", claims: map[string]any{"origin": "organization", "origin_id": "00000000-0000-0000-0000-000000000000"}, wantErr: `the gitlab.origin_id claim of the AutoFlow token is "00000000-0000-0000-0000-000000000000", not an organization UUID`},
377 }
378 for _, tc := range tests {
379 t.Run(tc.name, func(t *testing.T) {
380 t.Parallel()
382 relay := autoflowtest.NewRelay(t)
383 var gotBody tokenexchangetest.WireRequest
384 srv, _ := tokenexchangetest.NewTokenExchangeServer(t, autoflowtest.MakeToken(t, tc.claims), &gotBody)
385 exec := newTestExec(t, srv)
387 _, err := exec(relay.Args() + " --script x")
388 require.EqualError(t, err, tc.wantErr)
389 })
390 }
393func TestStart_TokenBindingFromEnvironment(t *testing.T) {
394 relay := autoflowtest.NewRelay(t)
395 calls := expectStart(relay, startedResponse, nil)
396 var gotBody tokenexchangetest.WireRequest
397 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
398 exec := newTestExec(t, srv)
399 binding := make([]byte, 64)
400 binding[0] = 7
401 t.Setenv("GLAB_AUTOFLOW_TOKEN_BINDING", base64.StdEncoding.EncodeToString(binding))
403 _, err := exec(relay.Args() + " --script x --idempotency-key my-key")
404 require.NoError(t, err)
405 assert.Equal(t, binding, autoflowtest.Received(t, calls).Req.GetTokenBinding())
408func TestStart_TokenBindingFileOverridesEnvironment(t *testing.T) {
409 fromFile := make([]byte, 64)
410 fromFile[0] = 1
411 t.Setenv("GLAB_AUTOFLOW_TOKEN_BINDING", base64.StdEncoding.EncodeToString(make([]byte, 64)))
412 relay := autoflowtest.NewRelay(t)
413 calls := expectStart(relay, startedResponse, nil)
414 var gotBody tokenexchangetest.WireRequest
415 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
416 exec := newTestExec(t, srv)
418 _, err := exec(relay.Args() + " --script x --idempotency-key my-key --token-binding-file " + autoflowtest.WriteFile(t, base64.StdEncoding.EncodeToString(fromFile)))
419 require.NoError(t, err)
420 assert.Equal(t, fromFile, autoflowtest.Received(t, calls).Req.GetTokenBinding())
423func TestStart_Resubmit(t *testing.T) {
424 t.Parallel()
426 relay := autoflowtest.NewRelay(t)
427 calls := expectStart(relay, startedResponse, nil)
428 var gotBody tokenexchangetest.WireRequest
429 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
430 exec := newTestExec(t, srv)
431 binding := make([]byte, 64)
432 for i := range binding {
433 binding[i] = byte(i)
434 }
435 encoded := base64.StdEncoding.EncodeToString(binding)
437 out, err := exec(relay.Args() + " --script x --idempotency-key my-key --token-binding-file " + autoflowtest.WriteFile(t, encoded+"\n"))
438 require.NoError(t, err)
440 gotReq := autoflowtest.Received(t, calls).Req
441 assert.Equal(t, "my-key", gotReq.GetIdempotencyKey())
442 assert.Equal(t, binding, gotReq.GetTokenBinding())
443 assert.Contains(t, out.OutBuf.String(), "token_binding: "+encoded+"\n")
446func TestStart_KwargsAndChannels(t *testing.T) {
447 t.Parallel()
449 relay := autoflowtest.NewRelay(t)
450 calls := expectStart(relay, &autoflowrpcv1.StartWorkflowResponse{
451 WorkflowKey: "wf-key",
452 WorkflowToken: "wf-token",
453 ChannelTokens: []*autoflowv1.ChannelToken{{ChannelName: "inbox", Token: "ch-token"}},
454 }, nil)
455 var gotBody tokenexchangetest.WireRequest
456 srv, _, _ := autoflowtest.NewTokenServer(t, &gotBody)
457 exec := newTestExec(t, srv)
459 out, err := exec(relay.Args() + ` --script x --kwarg count=2 --kwarg 'opts={"a": [true, null]}' --kwarg 'msg="a=b"' --channel inbox`)
460 require.NoError(t, err)
462 want := []*autoflowv1.Kwarg{
463 {Name: "count", Value: &autoflowv1.Value{Kind: &autoflowv1.Value_IntegerValue{IntegerValue: 2}}},
464 {Name: "opts", Value: &autoflowv1.Value{Kind: &autoflowv1.Value_DictValue{DictValue: &autoflowv1.DictValue{KeyValues: []*autoflowv1.KeyValue{{
465 Key: &autoflowv1.Value{Kind: &autoflowv1.Value_StringValue{StringValue: "a"}},
466 Val: &autoflowv1.Value{Kind: &autoflowv1.Value_ListValue{ListValue: &autoflowv1.ListValue{Values: []*autoflowv1.Value{
467 {Kind: &autoflowv1.Value_BoolValue{BoolValue: true}},
468 {Kind: &autoflowv1.Value_NoneValue{}},
469 }}}},
470 }}}}}},
471 {Name: "msg", Value: &autoflowv1.Value{Kind: &autoflowv1.Value_StringValue{StringValue: "a=b"}}},
472 {Name: "inbox", Value: &autoflowv1.Value{Kind: &autoflowv1.Value_ChannelValue{ChannelValue: &autoflowv1.ChannelValue{Name: "inbox"}}}},
473 }
474 got := autoflowtest.Received(t, calls).Req.GetKwargs()
475 require.Len(t, got, len(want))
476 for i := range want {
477 assert.True(t, proto.Equal(want[i], got[i]), "kwarg %d: got %v", i, got[i])
478 }
479 assert.Contains(t, out.OutBuf.String(), "token_binding: ")
480 assert.True(t, strings.HasSuffix(out.OutBuf.String(), "\nchannel_token.inbox: ch-token\n"), out.OutBuf.String())
483func TestStart_KwargErrors(t *testing.T) {
484 t.Parallel()
486 relay := autoflowtest.NewRelay(t)
487 tests := []struct {
488 name string
489 args string
490 wantErr string
491 }{
492 {name: "no equals sign", args: "--kwarg count", wantErr: "error parsing --kwarg count: want <name>=<JSON value>"},
493 {name: "invalid JSON", args: "--kwarg count=two", wantErr: "error parsing --kwarg count: invalid character"},
494 {name: "no name", args: "--kwarg =1", wantErr: "a keyword argument needs a name"},
495 {name: "duplicate kwarg", args: "--kwarg a=1 --kwarg a=2", wantErr: `keyword argument "a" is passed more than once`},
496 {name: "kwarg and channel", args: "--kwarg inbox=1 --channel inbox", wantErr: `keyword argument "inbox" is passed more than once`},
497 }
498 for _, tc := range tests {
499 t.Run(tc.name, func(t *testing.T) {
500 t.Parallel()
502 var gotBody tokenexchangetest.WireRequest
503 srv, count, _ := autoflowtest.NewTokenServer(t, &gotBody)
504 exec := newTestExec(t, srv)
506 _, err := exec(relay.Args() + " --script x " + tc.args)
507 require.Error(t, err)
508 assert.Contains(t, err.Error(), tc.wantErr)
509 assert.EqualValues(t, 0, count.Load())
510 })
511 }
Diagnostics9 git calls · 225 ms
CallStatusSizeTime0225 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
fetchtree:0 · deepen 1020032 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=32926
git.response.cache=HIT
git.response.duration_ms=4
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 · 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=1857
git.response.cache=HIT
git.response.duration_ms=3
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:0200173 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=173
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=9842465ba0bef0fe35148002069a98d0492349fa
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=173
git.pkt.payload.max=146
git.sideband.band1.bytes=146
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=146
git.pack.trailer=257bc2fe070f60e712099d7a0548db758c6c9692
Open pack map
fetchtree:0200227 B · hit5 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=5
git.response.bytes=227
git.response.cache=HIT
git.response.duration_ms=5
git.fetch.filter=tree:0
git.fetch.wants=d9a7c66bd00e9fc74c41d266132b2171a7a82cdd
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=227
git.pkt.payload.max=200
git.sideband.band1.bytes=200
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=200
git.pack.trailer=19b86a461d3d30a55c16a56ca10faa7dc7d8b30d
Open pack map
fetchtree:0200136 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=136
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=417aee58b2825878b951f7f6739908469c89caa4
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=136
git.pkt.payload.max=109
git.sideband.band1.bytes=109
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=109
git.pack.trailer=ef7a178af4c886044b197f966ebdc9429f58f968
Open pack map
fetch2004.3 KiB205 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=205
git.response.bytes=4373
git.response.cache=MISS
git.response.duration_ms=205
git.fetch.wants=0cdff0ea28afbe7dd3fd9cc200e5171d398bbed0
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=4373
git.pkt.payload.max=4346
git.sideband.band1.bytes=4346
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
a5e2e041a8fa2308
Request
5ffa3347…
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