GitLabgitlab-org
cli
main
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"
19)
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())
33}
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())
45}
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())
55}
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())
84}
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())
95}
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())
106}
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())
125}
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())
138}
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())
163}
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")
186}
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")
204}
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())
234}
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")
258}
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())
282}
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)
291}
293func TestParseRawPipelineIDsWithError(t *testing.T) {
294 t.Parallel()
296 pipelineIDs, err := parseRawPipelineIDs("test")
298 require.Error(t, err)
299 assert.Empty(t, pipelineIDs)
300}
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())
316}
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)
334}
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)
348}
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=44Open 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=fb03183b7909876778f740d196d7516811003517Open 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=178abb9456d874b7fd38fa21ad5cf9ca3ebcccaaOpen 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=a5319c2d5d28d769b9e23b59c3a2a96e5ec2d44aOpen 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