GitLabgitlab-org

cli

main
ply9 git calls227 ms99 KiB7 cachedprotocol v2
373 lines10 KiBRaw
1//go:build !integration
3package create
5import (
6 "encoding/json"
7 "errors"
8 "testing"
9 "time"
11 "github.com/stretchr/testify/assert"
12 "github.com/stretchr/testify/require"
13 "go.uber.org/mock/gomock"
15 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
16 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
18 "gitlab.com/gitlab-org/cli/internal/api"
19 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
22func TestCreateInstanceScope(t *testing.T) {
23 t.Parallel()
25 tc := gitlabtesting.NewTestClient(t)
27 exec := cmdtest.SetupCmdForTest(
28 t,
29 NewCmd,
30 false,
31 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
32 )
34 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
35 tc.MockRunnerControllerScopes.EXPECT().
36 AddRunnerControllerInstanceScope(int64(42), gomock.Any()).
37 Return(&gitlab.RunnerControllerInstanceLevelScoping{
38 CreatedAt: &fixedTime,
39 UpdatedAt: &fixedTime,
40 }, nil, nil)
42 out, err := exec("42 --instance")
43 require.NoError(t, err)
44 assert.Equal(t, "Added instance-level scope to runner controller 42\n", out.OutBuf.String())
47func TestCreateInstanceScopeJSON(t *testing.T) {
48 t.Parallel()
50 tc := gitlabtesting.NewTestClient(t)
52 exec := cmdtest.SetupCmdForTest(
53 t,
54 NewCmd,
55 false,
56 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
57 )
59 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
60 tc.MockRunnerControllerScopes.EXPECT().
61 AddRunnerControllerInstanceScope(int64(42), gomock.Any()).
62 Return(&gitlab.RunnerControllerInstanceLevelScoping{
63 CreatedAt: &fixedTime,
64 UpdatedAt: &fixedTime,
65 }, nil, nil)
67 out, err := exec("42 --instance --output json")
68 require.NoError(t, err)
70 var results []gitlab.RunnerControllerInstanceLevelScoping
71 err = json.Unmarshal(out.OutBuf.Bytes(), &results)
72 require.NoError(t, err)
74 require.Len(t, results, 1)
75 assert.Equal(t, fixedTime, *results[0].CreatedAt)
76 assert.Equal(t, fixedTime, *results[0].UpdatedAt)
79func TestCreateInstanceScopeError(t *testing.T) {
80 t.Parallel()
82 tc := gitlabtesting.NewTestClient(t)
84 exec := cmdtest.SetupCmdForTest(
85 t,
86 NewCmd,
87 false,
88 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
89 )
91 tc.MockRunnerControllerScopes.EXPECT().
92 AddRunnerControllerInstanceScope(int64(42), gomock.Any()).
93 Return(nil, nil, errors.New("API error"))
95 _, err := exec("42 --instance")
96 require.Error(t, err)
97 assert.Contains(t, err.Error(), "API error")
100func TestCreateRunnerScope(t *testing.T) {
101 t.Parallel()
103 tc := gitlabtesting.NewTestClient(t)
105 exec := cmdtest.SetupCmdForTest(
106 t,
107 NewCmd,
108 false,
109 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
110 )
112 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
113 tc.MockRunnerControllerScopes.EXPECT().
114 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
115 Return(&gitlab.RunnerControllerRunnerLevelScoping{
116 RunnerID: 5,
117 CreatedAt: &fixedTime,
118 UpdatedAt: &fixedTime,
119 }, nil, nil)
121 out, err := exec("42 --runner 5")
122 require.NoError(t, err)
123 assert.Equal(t, "Added runner-level scope for runner 5 to runner controller 42\n", out.OutBuf.String())
126func TestCreateRunnerScopeJSON(t *testing.T) {
127 t.Parallel()
129 tc := gitlabtesting.NewTestClient(t)
131 exec := cmdtest.SetupCmdForTest(
132 t,
133 NewCmd,
134 false,
135 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
136 )
138 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
139 tc.MockRunnerControllerScopes.EXPECT().
140 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
141 Return(&gitlab.RunnerControllerRunnerLevelScoping{
142 RunnerID: 5,
143 CreatedAt: &fixedTime,
144 UpdatedAt: &fixedTime,
145 }, nil, nil)
147 out, err := exec("42 --runner 5 --output json")
148 require.NoError(t, err)
150 var results []gitlab.RunnerControllerRunnerLevelScoping
151 err = json.Unmarshal(out.OutBuf.Bytes(), &results)
152 require.NoError(t, err)
154 require.Len(t, results, 1)
155 assert.Equal(t, int64(5), results[0].RunnerID)
156 assert.Equal(t, fixedTime, *results[0].CreatedAt)
157 assert.Equal(t, fixedTime, *results[0].UpdatedAt)
160func TestCreateMultipleRunnerScopes(t *testing.T) {
161 t.Parallel()
163 tc := gitlabtesting.NewTestClient(t)
165 exec := cmdtest.SetupCmdForTest(
166 t,
167 NewCmd,
168 false,
169 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
170 )
172 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
173 gomock.InOrder(
174 tc.MockRunnerControllerScopes.EXPECT().
175 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
176 Return(&gitlab.RunnerControllerRunnerLevelScoping{
177 RunnerID: 5,
178 CreatedAt: &fixedTime,
179 UpdatedAt: &fixedTime,
180 }, nil, nil),
181 tc.MockRunnerControllerScopes.EXPECT().
182 AddRunnerControllerRunnerScope(int64(42), int64(10), gomock.Any()).
183 Return(&gitlab.RunnerControllerRunnerLevelScoping{
184 RunnerID: 10,
185 CreatedAt: &fixedTime,
186 UpdatedAt: &fixedTime,
187 }, nil, nil),
188 )
190 out, err := exec("42 --runner 5 --runner 10")
191 require.NoError(t, err)
192 assert.Equal(t, "Added runner-level scope for runner 5 to runner controller 42\nAdded runner-level scope for runner 10 to runner controller 42\n", out.OutBuf.String())
195func TestCreateMultipleRunnerScopesCommaSeparated(t *testing.T) {
196 t.Parallel()
198 tc := gitlabtesting.NewTestClient(t)
200 exec := cmdtest.SetupCmdForTest(
201 t,
202 NewCmd,
203 false,
204 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
205 )
207 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
208 gomock.InOrder(
209 tc.MockRunnerControllerScopes.EXPECT().
210 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
211 Return(&gitlab.RunnerControllerRunnerLevelScoping{
212 RunnerID: 5,
213 CreatedAt: &fixedTime,
214 UpdatedAt: &fixedTime,
215 }, nil, nil),
216 tc.MockRunnerControllerScopes.EXPECT().
217 AddRunnerControllerRunnerScope(int64(42), int64(10), gomock.Any()).
218 Return(&gitlab.RunnerControllerRunnerLevelScoping{
219 RunnerID: 10,
220 CreatedAt: &fixedTime,
221 UpdatedAt: &fixedTime,
222 }, nil, nil),
223 )
225 out, err := exec("42 --runner 5,10")
226 require.NoError(t, err)
227 assert.Equal(t, "Added runner-level scope for runner 5 to runner controller 42\nAdded runner-level scope for runner 10 to runner controller 42\n", out.OutBuf.String())
230func TestCreateMultipleRunnerScopesJSON(t *testing.T) {
231 t.Parallel()
233 tc := gitlabtesting.NewTestClient(t)
235 exec := cmdtest.SetupCmdForTest(
236 t,
237 NewCmd,
238 false,
239 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
240 )
242 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
243 gomock.InOrder(
244 tc.MockRunnerControllerScopes.EXPECT().
245 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
246 Return(&gitlab.RunnerControllerRunnerLevelScoping{
247 RunnerID: 5,
248 CreatedAt: &fixedTime,
249 UpdatedAt: &fixedTime,
250 }, nil, nil),
251 tc.MockRunnerControllerScopes.EXPECT().
252 AddRunnerControllerRunnerScope(int64(42), int64(10), gomock.Any()).
253 Return(&gitlab.RunnerControllerRunnerLevelScoping{
254 RunnerID: 10,
255 CreatedAt: &fixedTime,
256 UpdatedAt: &fixedTime,
257 }, nil, nil),
258 )
260 out, err := exec("42 --runner 5,10 --output json")
261 require.NoError(t, err)
263 var results []gitlab.RunnerControllerRunnerLevelScoping
264 err = json.Unmarshal(out.OutBuf.Bytes(), &results)
265 require.NoError(t, err)
267 require.Len(t, results, 2)
268 assert.Equal(t, int64(5), results[0].RunnerID)
269 assert.Equal(t, int64(10), results[1].RunnerID)
272func TestCreateMultipleRunnerScopesPartialError(t *testing.T) {
273 t.Parallel()
275 tc := gitlabtesting.NewTestClient(t)
277 exec := cmdtest.SetupCmdForTest(
278 t,
279 NewCmd,
280 false,
281 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
282 )
284 fixedTime := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
285 gomock.InOrder(
286 tc.MockRunnerControllerScopes.EXPECT().
287 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
288 Return(&gitlab.RunnerControllerRunnerLevelScoping{
289 RunnerID: 5,
290 CreatedAt: &fixedTime,
291 UpdatedAt: &fixedTime,
292 }, nil, nil),
293 tc.MockRunnerControllerScopes.EXPECT().
294 AddRunnerControllerRunnerScope(int64(42), int64(10), gomock.Any()).
295 Return(nil, nil, errors.New("API error")),
296 )
298 _, err := exec("42 --runner 5,10")
299 require.Error(t, err)
300 assert.Contains(t, err.Error(), "API error")
303func TestCreateRunnerScopeError(t *testing.T) {
304 t.Parallel()
306 tc := gitlabtesting.NewTestClient(t)
308 exec := cmdtest.SetupCmdForTest(
309 t,
310 NewCmd,
311 false,
312 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
313 )
315 tc.MockRunnerControllerScopes.EXPECT().
316 AddRunnerControllerRunnerScope(int64(42), int64(5), gomock.Any()).
317 Return(nil, nil, errors.New("API error"))
319 _, err := exec("42 --runner 5")
320 require.Error(t, err)
321 assert.Contains(t, err.Error(), "API error")
324func TestCreateRequiresScopeType(t *testing.T) {
325 t.Parallel()
327 tc := gitlabtesting.NewTestClient(t)
329 exec := cmdtest.SetupCmdForTest(
330 t,
331 NewCmd,
332 false,
333 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
334 )
336 _, err := exec("42")
337 require.Error(t, err)
338 assert.Contains(t, err.Error(), "at least one of the flags in the group [instance runner] is required")
341func TestCreateMutuallyExclusive(t *testing.T) {
342 t.Parallel()
344 tc := gitlabtesting.NewTestClient(t)
346 exec := cmdtest.SetupCmdForTest(
347 t,
348 NewCmd,
349 false,
350 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
351 )
353 _, err := exec("42 --instance --runner 5")
354 require.Error(t, err)
355 assert.Contains(t, err.Error(), "if any flags in the group [instance runner] are set none of the others can be")
358func TestCreateInvalidID(t *testing.T) {
359 t.Parallel()
361 tc := gitlabtesting.NewTestClient(t)
363 exec := cmdtest.SetupCmdForTest(
364 t,
365 NewCmd,
366 false,
367 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "", "", api.WithGitLabClient(tc.Client))),
368 )
370 _, err := exec("invalid --instance")
371 require.Error(t, err)
372 assert.Contains(t, err.Error(), `invalid runner controller ID: "invalid"`)
Diagnostics9 git calls · 227 ms
CallStatusSizeTime0227 ms
discover200185 B3 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 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 · 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=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 · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=7
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:02001.8 KiB · hit7 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=1857
git.response.cache=HIT
git.response.duration_ms=7
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:0200323 B · hit5 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=323
git.response.cache=HIT
git.response.duration_ms=5
git.fetch.filter=tree:0
git.fetch.wants=8185a1b139a07a59fba10180a7318233adb22fc3
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=323
git.pkt.payload.max=296
git.sideband.band1.bytes=296
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=296
git.pack.trailer=ac106711ec2e15414437a5964de4b85c86703290
Open pack map
fetchtree:0200196 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=6
git.response.bytes=196
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=2457618d95f2bcb98ae5f01c872bb42789a59b56
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=196
git.pkt.payload.max=169
git.sideband.band1.bytes=169
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=169
git.pack.trailer=02c3a461145a7ea4fb72afbfd8909e6ed3eedc5a
Open pack map
fetchtree:0200138 B · hit6 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=200
git.response.bytes=138
git.response.cache=HIT
git.response.duration_ms=6
git.fetch.filter=tree:0
git.fetch.wants=de1c4238be0bb0dd2a2fe8a34c32720cfc8e232f
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=138
git.pkt.payload.max=111
git.sideband.band1.bytes=111
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=111
git.pack.trailer=a71b46066d197c28e9cdffbb5427f00ffaf994df
Open pack map
fetch2001.2 KiB200 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=1194
git.response.cache=MISS
git.response.duration_ms=200
git.fetch.wants=35b856890a422d000a81d754cba593d85de92698
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=1194
git.pkt.payload.max=1167
git.sideband.band1.bytes=1167
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
a5e219e3dc88ecd4
Request
044e368d…
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