GitLabgitlab-org

cli

main
ply9 git calls199 ms100 KiB7 cachedprotocol v2
316 lines11 KiBRaw
1//go:build !integration
3package get
5import (
6 "encoding/json"
7 "testing"
8 "time"
10 "github.com/google/uuid"
11 "github.com/stretchr/testify/assert"
12 "github.com/stretchr/testify/require"
13 autoflowrpcv1 "gitlab.com/gitlab-org/protos/gen/go/gitlab/autoflow/rpc/v1"
14 autoflowv1 "gitlab.com/gitlab-org/protos/gen/go/gitlab/autoflow/v1"
15 "go.uber.org/mock/gomock"
16 "google.golang.org/grpc/codes"
17 "google.golang.org/grpc/status"
18 "google.golang.org/protobuf/types/known/timestamppb"
20 "gitlab.com/gitlab-org/cli/internal/testing/autoflowtest"
21 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
22 "gitlab.com/gitlab-org/cli/internal/testing/tokenexchangetest"
25type getCall = autoflowtest.Call[*autoflowrpcv1.GetWorkflowRequest]
27var (
28 createdAt = time.Date(2026, 11, 6, 14, 0, 0, 0, time.UTC)
29 updatedAt = createdAt.Add(111 * time.Millisecond)
32func workflowIn(state autoflowrpcv1.WorkflowState, result *autoflowv1.Result) *autoflowrpcv1.GetWorkflowResponse {
33 return &autoflowrpcv1.GetWorkflowResponse{
34 WorkflowKey: "wf-key",
35 Name: "main",
36 IdempotencyKey: "my-key",
37 State: state,
38 CreatedAt: timestamppb.New(createdAt),
39 UpdatedAt: timestamppb.New(updatedAt),
40 Result: result,
41 }
44var completed = workflowIn(autoflowrpcv1.WorkflowState_WORKFLOW_STATE_COMPLETED, &autoflowv1.Result{
45 Result: &autoflowv1.Result_Value{Value: &autoflowv1.Value{Kind: &autoflowv1.Value_IntegerValue{IntegerValue: 1}}},
46})
48// expectGet makes the relay answer GetWorkflow with resps, in order.
49func expectGet(relay *autoflowtest.Relay, resps ...*autoflowrpcv1.GetWorkflowResponse) <-chan getCall {
50 calls := make(chan getCall, len(resps))
51 for _, resp := range resps {
52 relay.Mock.EXPECT().GetWorkflow(gomock.Any(), gomock.Any()).DoAndReturn(autoflowtest.Answer(calls, resp, nil))
53 }
54 return calls
57func TestGet_Text(t *testing.T) {
58 t.Parallel()
60 relay := autoflowtest.NewRelay(t)
61 calls := expectGet(relay, completed)
62 exec, token := autoflowtest.NewTestExec(t, NewCmd)
64 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token\n"))
65 require.NoError(t, err)
67 call := autoflowtest.Received(t, calls)
68 assert.Equal(t, []string{"Bearer " + token}, call.Auth)
69 assert.Equal(t, "wf-key", call.Req.GetWorkflowKey())
70 assert.Equal(t, "wf-token", call.Req.GetWorkflowToken())
71 wantNamespace := uuid.MustParse(autoflowtest.NamespaceID)
72 assert.Equal(t, wantNamespace[:], call.Req.GetNamespaceId())
74 assert.Equal(t, "workflow_key: wf-key\n"+
75 "name: main\n"+
76 "idempotency_key: my-key\n"+
77 "state: COMPLETED\n"+
78 "created_at: 2026-11-06T14:00:00Z\n"+
79 "updated_at: 2026-11-06T14:00:00.111Z\n"+
80 "value: 1\n",
81 out.OutBuf.String())
84func TestGet_TokenFromEnvironment(t *testing.T) {
85 relay := autoflowtest.NewRelay(t)
86 calls := expectGet(relay, completed)
87 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
88 t.Setenv("GLAB_AUTOFLOW_WORKFLOW_TOKEN", "env-token")
90 _, err := exec("wf-key " + relay.Args())
91 require.NoError(t, err)
92 assert.Equal(t, "env-token", autoflowtest.Received(t, calls).Req.GetWorkflowToken())
95func TestGet_TokenFromStdin(t *testing.T) {
96 t.Parallel()
98 relay := autoflowtest.NewRelay(t)
99 calls := expectGet(relay, completed)
100 exec, _ := autoflowtest.NewTestExec(t, NewCmd, cmdtest.WithStdin("stdin-token\n"))
102 _, err := exec("wf-key " + relay.Args() + " --workflow-token-file -")
103 require.NoError(t, err)
104 assert.Equal(t, "stdin-token", autoflowtest.Received(t, calls).Req.GetWorkflowToken())
107func TestGet_JSONFailed(t *testing.T) {
108 t.Parallel()
110 relay := autoflowtest.NewRelay(t)
111 expectGet(relay, workflowIn(autoflowrpcv1.WorkflowState_WORKFLOW_STATE_FAILED, &autoflowv1.Result{
112 Result: &autoflowv1.Result_Error{Error: &autoflowv1.Error{Message: "boom"}},
113 }))
114 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
116 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --output json")
117 require.NoError(t, err, "without --wait a failed workflow is a successful read")
119 var got map[string]any
120 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &got))
121 assert.Equal(t, map[string]any{
122 "workflow_key": "wf-key",
123 "name": "main",
124 "idempotency_key": "my-key",
125 "state": "FAILED",
126 "created_at": "2026-11-06T14:00:00Z",
127 "updated_at": "2026-11-06T14:00:00.111Z",
128 "error": "boom",
129 }, got)
132func TestGet_WaitUntilCompleted(t *testing.T) {
133 t.Parallel()
135 relay := autoflowtest.NewRelay(t)
136 calls := expectGet(relay, workflowIn(autoflowrpcv1.WorkflowState_WORKFLOW_STATE_RUNNING, nil), completed)
137 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
139 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait --poll-interval 1ms")
140 require.NoError(t, err)
141 assert.Len(t, calls, 2)
142 assert.Contains(t, out.OutBuf.String(), "state: COMPLETED\n")
145func TestGet_WaitUntilCanceled(t *testing.T) {
146 t.Parallel()
148 relay := autoflowtest.NewRelay(t)
149 expectGet(relay, workflowIn(autoflowrpcv1.WorkflowState_WORKFLOW_STATE_CANCELED, nil))
150 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
152 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait")
153 require.EqualError(t, err, "workflow finished in state CANCELED")
154 assert.Contains(t, out.OutBuf.String(), "state: CANCELED\n")
157func TestGet_ValueFormatProtojson(t *testing.T) {
158 t.Parallel()
160 relay := autoflowtest.NewRelay(t)
161 expectGet(relay, completed)
162 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
164 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --value-format protojson --output json --jq .value")
165 require.NoError(t, err)
166 assert.JSONEq(t, `{"integer_value":"1"}`, out.OutBuf.String())
169func TestGet_WaitRetriesTransientFailures(t *testing.T) {
170 t.Parallel()
172 relay := autoflowtest.NewRelay(t)
173 gomock.InOrder(
174 relay.Mock.EXPECT().GetWorkflow(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.Unavailable, "relay restarting")),
175 relay.Mock.EXPECT().GetWorkflow(gomock.Any(), gomock.Any()).Return(&autoflowrpcv1.GetWorkflowResponse{
176 WorkflowKey: "wf-key",
177 State: autoflowrpcv1.WorkflowState_WORKFLOW_STATE_COMPLETED,
178 }, nil),
179 )
180 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
182 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait --poll-interval 1ms")
183 require.NoError(t, err)
184 assert.Equal(t, "workflow_key: wf-key\nname: \nidempotency_key: \nstate: COMPLETED\n", out.OutBuf.String(), "a missing timestamp is omitted")
187func TestGet_WaitGivesUpOnOtherFailures(t *testing.T) {
188 t.Parallel()
190 relay := autoflowtest.NewRelay(t)
191 relay.Mock.EXPECT().GetWorkflow(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.PermissionDenied, "workflow token does not match"))
192 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
194 _, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait --poll-interval 1ms")
195 require.Error(t, err)
196 assert.Equal(t, codes.PermissionDenied, status.Code(err))
199func TestGet_WaitGivesUpAfterRepeatedTransientFailures(t *testing.T) {
200 t.Parallel()
202 relay := autoflowtest.NewRelay(t)
203 relay.Mock.EXPECT().GetWorkflow(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.Unavailable, "relay down")).Times(6)
204 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
206 _, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait --poll-interval 1ms")
207 require.Error(t, err)
208 assert.Equal(t, codes.Unavailable, status.Code(err))
211func TestGet_WaitEndsOnUnknownState(t *testing.T) {
212 t.Parallel()
214 relay := autoflowtest.NewRelay(t)
215 expectGet(relay, workflowIn(autoflowrpcv1.WorkflowState(99), nil))
216 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
218 _, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait")
219 require.EqualError(t, err, "workflow finished in state 99")
222func TestGet_RelayError(t *testing.T) {
223 t.Parallel()
225 relay := autoflowtest.NewRelay(t)
226 relay.Mock.EXPECT().GetWorkflow(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.PermissionDenied, "namespace does not match the token's organization"))
227 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
229 out, err := exec("wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token"))
230 require.Error(t, err)
231 assert.Equal(t, codes.PermissionDenied, status.Code(err))
232 assert.Contains(t, err.Error(), "failed to get workflow")
233 assert.Empty(t, out.OutBuf.String())
236func TestGet_FlagErrors(t *testing.T) {
237 t.Parallel()
239 relay := autoflowtest.NewRelay(t)
240 tests := []struct {
241 name string
242 args string
243 wantErr string
244 }{
245 {
246 name: "no workflow key",
247 args: relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token"),
248 wantErr: "accepts 1 arg(s), received 0",
249 },
250 {
251 name: "no workflow token",
252 args: "wf-key " + relay.Args(),
253 wantErr: "pass --workflow-token-file or set GLAB_AUTOFLOW_WORKFLOW_TOKEN",
254 },
255 {
256 name: "empty workflow token",
257 args: "wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, " \n"),
258 wantErr: "the workflow token is empty",
259 },
260 {
261 name: "missing workflow token file",
262 args: "wf-key " + relay.Args() + " --workflow-token-file /nonexistent/token",
263 wantErr: "failed to read --workflow-token-file",
264 },
265 {
266 name: "no address",
267 args: "wf-key --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token"),
268 wantErr: `required flag(s) "address" not set`,
269 },
270 {
271 name: "poll interval not positive",
272 args: "wf-key " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token") + " --wait --poll-interval 0s",
273 wantErr: "--poll-interval must be positive, got 0s",
274 },
275 }
277 for _, tc := range tests {
278 t.Run(tc.name, func(t *testing.T) {
279 t.Parallel()
281 var gotBody tokenexchangetest.WireRequest
282 srv, count, _ := autoflowtest.NewTokenServer(t, &gotBody)
283 exec := tokenexchangetest.NewTestExec(t, srv, NewCmd)
285 _, err := exec(tc.args)
286 require.Error(t, err)
287 assert.Contains(t, err.Error(), tc.wantErr)
288 assert.EqualValues(t, 0, count.Load())
289 })
290 }
293func TestGet_Insecure(t *testing.T) {
294 t.Parallel()
296 relay := autoflowtest.NewCleartextRelay(t)
297 calls := expectGet(relay, completed)
298 exec, token := autoflowtest.NewTestExec(t, NewCmd)
300 out, err := exec("wf-key --insecure --address " + relay.Address + " --namespace-id " + autoflowtest.NamespaceID + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token"))
301 require.NoError(t, err)
302 assert.Equal(t, []string{"Bearer " + token}, autoflowtest.Received(t, calls).Auth)
303 assert.Equal(t, "warning: --insecure sends the AutoFlow token and the workflow's credentials to "+relay.Address+" in cleartext\n", out.ErrBuf.String())
304 assert.Contains(t, out.OutBuf.String(), "state: COMPLETED\n")
307func TestGet_InsecureAndCACert(t *testing.T) {
308 t.Parallel()
310 relay := autoflowtest.NewRelay(t)
311 exec, _ := autoflowtest.NewTestExec(t, NewCmd)
313 _, err := exec("wf-key --insecure " + relay.Args() + " --workflow-token-file " + autoflowtest.WriteFile(t, "wf-token"))
314 require.Error(t, err)
315 assert.Contains(t, err.Error(), "if any flags in the group [insecure ca-cert] are set none of the others can be")
Diagnostics9 git calls · 199 ms
CallStatusSizeTime0199 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 · 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=2
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 · hit2 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=2
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=2
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 · 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=1857
git.response.cache=HIT
git.response.duration_ms=1
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 · 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=227
git.response.cache=HIT
git.response.duration_ms=2
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:0200134 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=134
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=e699c957590e8574d1181448e231e5ffdf182f2e
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=134
git.pkt.payload.max=107
git.sideband.band1.bytes=107
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=107
git.pack.trailer=5c9b6f12321aeb06c6347ee48ab720cceaff3c5a
Open pack map
fetch2002.6 KiB186 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=186
git.response.bytes=2629
git.response.cache=MISS
git.response.duration_ms=186
git.fetch.wants=d3a7128b5b7c416215c8bb4a51aaa18e22926ccf
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=2629
git.pkt.payload.max=2602
git.sideband.band1.bytes=2602
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
a5e2e563999f2947
Request
a70c6bb4…
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