GitLabgitlab-org

cli

main
ply8 git calls275 ms99 KiB5 cachedprotocol v2
348 lines11 KiBRaw
1//go:build !integration
3package delete
5import (
6 "errors"
7 "testing"
8 "time"
10 "github.com/spf13/pflag"
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/testing/cmdtest"
21func TestCIDelete(t *testing.T) {
22 t.Parallel()
24 tc := gitlabtesting.NewTestClient(t)
25 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, nil)
26 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
28 out, err := exec("11111111")
29 require.NoError(t, err)
31 assert.Contains(t, out.OutBuf.String(), "Pipeline #11111111 deleted successfully.")
32 assert.Empty(t, out.ErrBuf.String())
35func TestCIDeleteNonExistingPipeline(t *testing.T) {
36 t.Parallel()
38 tc := gitlabtesting.NewTestClient(t)
39 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, errors.New(`{"message": "404 Not found"}`))
40 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
42 out, err := exec("11111111")
43 require.Error(t, err)
44 assert.Empty(t, out.OutBuf.String())
47func TestCIDeleteWithWrongArgument(t *testing.T) {
48 t.Parallel()
50 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false)
52 out, err := exec("test")
53 require.Error(t, err)
54 assert.Empty(t, out.OutBuf.String())
57func TestCIDeleteByStatus(t *testing.T) {
58 t.Parallel()
60 tc := gitlabtesting.NewTestClient(t)
61 gomock.InOrder(
62 tc.MockPipelines.EXPECT().
63 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
64 Return([]*gitlab.PipelineInfo{
65 {
66 ID: 11111111,
67 },
68 {
69 ID: 22222222,
70 },
71 }, &gitlab.Response{NextPage: 0}, nil),
72 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, nil),
73 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(22222222)).Return(nil, nil),
74 )
75 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
77 out, err := exec("--status=success")
78 require.NoError(t, err)
80 stdout := out.OutBuf.String()
81 assert.Contains(t, stdout, "Pipeline #11111111 deleted successfully.")
82 assert.Contains(t, stdout, "Pipeline #22222222 deleted successfully.")
83 assert.Empty(t, out.ErrBuf.String())
86func TestCIDeleteByStatusFailsWithArgument(t *testing.T) {
87 t.Parallel()
89 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false)
90 out, err := exec("--status=success 11111111")
91 require.EqualError(t, err, "either a status filter or a pipeline ID must be passed, but not both")
93 assert.Empty(t, out.OutBuf.String())
94 assert.Empty(t, out.ErrBuf.String())
97func TestCIDeleteWithoutFilterFailsWithoutArgument(t *testing.T) {
98 t.Parallel()
100 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false)
101 out, err := exec("")
102 require.EqualError(t, err, "accepts 1 arg(s), received 0")
104 assert.Empty(t, out.OutBuf.String())
105 assert.Empty(t, out.ErrBuf.String())
108func TestCIDeleteMultiple(t *testing.T) {
109 t.Parallel()
111 tc := gitlabtesting.NewTestClient(t)
112 gomock.InOrder(
113 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, nil),
114 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(22222222)).Return(nil, nil),
115 )
116 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
118 out, err := exec("11111111,22222222")
119 require.NoError(t, err)
121 stdout := out.OutBuf.String()
122 assert.Contains(t, stdout, "Pipeline #11111111 deleted successfully.")
123 assert.Contains(t, stdout, "Pipeline #22222222 deleted successfully.")
124 assert.Empty(t, out.ErrBuf.String())
127func TestCIDryRunDeleteNothing(t *testing.T) {
128 t.Parallel()
130 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false)
131 out, err := exec("--dry-run 11111111,22222222")
132 require.NoError(t, err)
134 stdout := out.OutBuf.String()
135 assert.Contains(t, stdout, "Pipeline #11111111 will be deleted.")
136 assert.Contains(t, stdout, "Pipeline #22222222 will be deleted.")
137 assert.Empty(t, out.ErrBuf.String())
140func TestCIDeletedDryRunWithFilterDoesNotDelete(t *testing.T) {
141 t.Parallel()
143 tc := gitlabtesting.NewTestClient(t)
144 tc.MockPipelines.EXPECT().
145 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
146 Return([]*gitlab.PipelineInfo{
147 {
148 ID: 11111111,
149 },
150 {
151 ID: 22222222,
152 },
153 }, &gitlab.Response{NextPage: 0}, nil)
154 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
156 out, err := exec("--dry-run --status=success")
157 require.NoError(t, err)
159 stdout := out.OutBuf.String()
160 assert.Contains(t, stdout, "Pipeline #11111111 will be deleted.")
161 assert.Contains(t, stdout, "Pipeline #22222222 will be deleted.")
162 assert.Empty(t, out.ErrBuf.String())
165func TestCIDeleteByStatusWarnsWhenResultsTruncated(t *testing.T) {
166 t.Parallel()
168 tc := gitlabtesting.NewTestClient(t)
169 gomock.InOrder(
170 tc.MockPipelines.EXPECT().
171 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
172 Return([]*gitlab.PipelineInfo{
173 {ID: 11111111},
174 {ID: 22222222},
175 }, &gitlab.Response{NextPage: 2, CurrentPage: 1, TotalPages: 4, TotalItems: 67}, nil),
176 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, nil),
177 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(22222222)).Return(nil, nil),
178 )
179 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
181 out, err := exec("--status=success")
182 require.NoError(t, err)
184 assert.Contains(t, out.ErrBuf.String(), "Deleted 2 of 67 matching pipelines")
185 assert.Contains(t, out.ErrBuf.String(), "--paginate")
188func TestCIDeleteByStatusDryRunWarnsWhenResultsTruncated(t *testing.T) {
189 t.Parallel()
191 tc := gitlabtesting.NewTestClient(t)
192 tc.MockPipelines.EXPECT().
193 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
194 Return([]*gitlab.PipelineInfo{
195 {ID: 11111111},
196 {ID: 22222222},
197 }, &gitlab.Response{NextPage: 2, CurrentPage: 1, TotalPages: 4, TotalItems: 67}, nil)
198 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
200 out, err := exec("--dry-run --status=success")
201 require.NoError(t, err)
203 assert.Contains(t, out.ErrBuf.String(), "Matched 2 of 67 matching pipelines")
206func TestCIDeletePaginateTerminatesWithoutTotalPages(t *testing.T) {
207 t.Parallel()
209 tc := gitlabtesting.NewTestClient(t)
210 gomock.InOrder(
211 tc.MockPipelines.EXPECT().
212 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
213 Return([]*gitlab.PipelineInfo{
214 {ID: 11111111},
215 }, &gitlab.Response{NextPage: 2, CurrentPage: 1}, nil),
216 tc.MockPipelines.EXPECT().
217 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success), ListOptions: gitlab.ListOptions{Page: 2}}).
218 Return([]*gitlab.PipelineInfo{
219 {ID: 22222222},
220 }, &gitlab.Response{NextPage: 0, CurrentPage: 2}, nil),
221 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, nil),
222 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(22222222)).Return(nil, nil),
223 )
224 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
226 out, err := exec("--paginate --status=success")
227 require.NoError(t, err)
229 stdout := out.OutBuf.String()
230 assert.Contains(t, stdout, "Pipeline #11111111 deleted successfully.")
231 assert.Contains(t, stdout, "Pipeline #22222222 deleted successfully.")
232 // Fully paginated: no truncation warning expected.
233 assert.Empty(t, out.ErrBuf.String())
236func TestCIDeleteByStatusWarnsWhenTruncatedWithoutTotal(t *testing.T) {
237 t.Parallel()
239 tc := gitlabtesting.NewTestClient(t)
240 gomock.InOrder(
241 tc.MockPipelines.EXPECT().
242 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
243 Return([]*gitlab.PipelineInfo{
244 {ID: 11111111},
245 {ID: 22222222},
246 }, &gitlab.Response{NextPage: 2, CurrentPage: 1}, nil),
247 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(11111111)).Return(nil, nil),
248 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(22222222)).Return(nil, nil),
249 )
250 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
252 out, err := exec("--status=success")
253 require.NoError(t, err)
255 stderr := out.ErrBuf.String()
256 assert.Contains(t, stderr, "Deleted 2 matching pipelines; more matches exist")
257 assert.Contains(t, stderr, "--paginate")
260func TestCIDeleteBySource(t *testing.T) {
261 t.Parallel()
263 tc := gitlabtesting.NewTestClient(t)
264 gomock.InOrder(
265 tc.MockPipelines.EXPECT().
266 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Source: new("push")}).
267 Return([]*gitlab.PipelineInfo{
268 {
269 ID: 22222222,
270 },
271 }, &gitlab.Response{NextPage: 0}, nil),
272 tc.MockPipelines.EXPECT().DeletePipeline("OWNER/REPO", int64(22222222)).Return(nil, nil),
273 )
274 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
276 out, err := exec("--source=push")
277 require.NoError(t, err)
279 stdout := out.OutBuf.String()
280 assert.Contains(t, stdout, "Pipeline #22222222 deleted successfully.")
281 assert.Empty(t, out.ErrBuf.String())
284func TestParseRawPipelineIDsCorrectly(t *testing.T) {
285 t.Parallel()
287 pipelineIDs, err := parseRawPipelineIDs("1,2,3")
289 require.NoError(t, err)
290 assert.Equal(t, []int{1, 2, 3}, pipelineIDs)
293func TestParseRawPipelineIDsWithError(t *testing.T) {
294 t.Parallel()
296 pipelineIDs, err := parseRawPipelineIDs("test")
298 require.Error(t, err)
299 assert.Empty(t, pipelineIDs)
302func TestExtractPipelineIDsFromFlagsWithError(t *testing.T) {
303 t.Parallel()
305 tc := gitlabtesting.NewTestClient(t)
306 tc.MockPipelines.EXPECT().
307 ListProjectPipelines("OWNER/REPO", &gitlab.ListProjectPipelinesOptions{Status: new(gitlab.Success)}).
308 Return(nil, nil, errors.New(`{"message": "403 Forbidden"}`))
309 exec := cmdtest.SetupCmdForTest(t, NewCmdDelete, false, cmdtest.WithGitLabClient(tc.Client))
311 out, err := exec("--status=success")
312 require.Error(t, err)
314 assert.Empty(t, out.OutBuf.String())
315 assert.Empty(t, out.ErrBuf.String())
318func TestOptsFromFlags(t *testing.T) {
319 t.Parallel()
321 flags := pflag.NewFlagSet("test-flagset", pflag.ContinueOnError)
322 SetupCommandFlags(flags)
324 require.NoError(t, flags.Parse([]string{"--status", "success", "--older-than", "24h"}))
326 opts := optsFromFlags(flags)
328 assert.Nil(t, opts.Source)
329 assert.Equal(t, opts.Status, new(gitlab.BuildStateValue("success")))
331 lowerTimeBoundary := time.Now().Add(-1 * 24 * time.Hour).Add(-5 * time.Second)
332 upperTimeBoundary := time.Now().Add(-1 * 24 * time.Hour).Add(5 * time.Second)
333 assert.WithinRange(t, *opts.UpdatedBefore, lowerTimeBoundary, upperTimeBoundary)
336func TestOptsFromFlagsWithPagination(t *testing.T) {
337 t.Parallel()
339 flags := pflag.NewFlagSet("test-flagset", pflag.ContinueOnError)
340 SetupCommandFlags(flags)
342 require.NoError(t, flags.Parse([]string{"--page", "5", "--per-page", "10"}))
344 opts := optsFromFlags(flags)
346 assert.Equal(t, int64(5), opts.Page)
347 assert.Equal(t, int64(10), opts.PerPage)
Diagnostics8 git calls · 275 ms
CallStatusSizeTime0275 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 KiB2 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=UPDATING
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=2
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 · 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:0200635 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=635
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=517b073a0d5c32bc4e93f86de74b31d60ff8cf03
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=635
git.pkt.payload.max=608
git.sideband.band1.bytes=608
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=608
git.pack.trailer=178abb9456d874b7fd38fa21ad5cf9ca3ebcccaa
Open pack map
fetchtree:0200138 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=138
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=8cd12e229b33292c7d4ce2310e8accbcf780f249
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=a5319c2d5d28d769b9e23b59c3a2a96e5ec2d44a
Open pack map
fetch2001.7 KiB260 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=260
git.response.bytes=1736
git.response.cache=MISS
git.response.duration_ms=260
git.fetch.wants=d3be7ec57b671181189bc6a6e310d8d17ee3a6b3
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=1736
git.pkt.payload.max=1709
git.sideband.band1.bytes=1709
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
a5e2c1407ec989da
Request
41ca2871…
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