GitLabgitlab-org

cli

main
ply8 git calls236 ms105 KiB6 cachedprotocol v2
1414 lines52 KiBRaw
1//go:build !integration
3package create
5import (
6 "context"
7 "encoding/json"
8 "errors"
9 "net/http"
10 "net/http/httptest"
11 "os"
12 "path/filepath"
13 "testing"
14 "time"
16 "git.sr.ht/~timofurrer/ugh"
17 "github.com/spf13/cobra"
18 "github.com/stretchr/testify/assert"
19 "github.com/stretchr/testify/require"
20 "go.uber.org/mock/gomock"
22 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
23 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
25 "gitlab.com/gitlab-org/cli/internal/cmdutils"
26 "gitlab.com/gitlab-org/cli/internal/commands/release/releaseutils/upload"
27 "gitlab.com/gitlab-org/cli/internal/config"
28 "gitlab.com/gitlab-org/cli/internal/glinstance"
29 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
32func TestReleaseCreate(t *testing.T) {
33 t.Setenv("CI_DEFAULT_BRANCH", "main")
35 tests := []struct {
36 name string
37 cli string
39 expectedDescription string
40 expectedTagMessage string
41 }{
42 {
43 name: "when a release is created",
44 cli: "0.0.1 --notes \"test release\"",
45 },
46 {
47 name: "when a release is created with a description",
48 cli: `0.0.1 --notes "bugfix release"`,
49 expectedDescription: "bugfix release",
50 },
51 {
52 name: "when a release is created with a tag message",
53 cli: `0.0.1 --notes "test release" --tag-message "tag message"`,
54 expectedTagMessage: "tag message",
55 },
56 }
58 for _, tc := range tests {
59 t.Run(tc.name, func(t *testing.T) {
60 testClient := gitlabtesting.NewTestClient(t)
62 exec := cmdtest.SetupCmdForTest(
63 t,
64 NewCmdCreate,
65 false,
66 cmdtest.WithGitLabClient(testClient.Client),
67 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
68 )
70 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
72 // Tag exists
73 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
75 // Release doesn't exist
76 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
78 // Create release - verify options
79 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
80 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
81 assert.Equal(t, "0.0.1", *opts.TagName)
82 if tc.expectedDescription != "" {
83 require.NotNil(t, opts.Description)
84 assert.Equal(t, tc.expectedDescription, *opts.Description)
85 }
86 if tc.expectedTagMessage != "" {
87 require.NotNil(t, opts.TagMessage)
88 assert.Equal(t, tc.expectedTagMessage, *opts.TagMessage)
89 }
90 return &gitlab.Release{
91 Name: "test_release",
92 TagName: "0.0.1",
93 Description: "bugfix release",
94 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
95 }, nil, nil
96 })
98 output, err := exec(tc.cli)
100 if assert.NoErrorf(t, err, "error running command `create %s`: %v", tc.cli, err) {
101 assert.Contains(t, output.String(), `• Validating tag 0.0.1
102• Creating or updating release repo=OWNER/REPO tag=0.0.1
103✓ Release created: url=https://gitlab.com/OWNER/REPO/-/releases/0.0.1
104✓ Release succeeded after`)
105 assert.Empty(t, output.Stderr())
106 }
107 })
108 }
111func TestReleaseCreate_LongReleasedAtReturnsError(t *testing.T) {
112 testClient := gitlabtesting.NewTestClient(t)
113 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
114 testClient.MockTags.EXPECT().
115 GetTag("OWNER/REPO", "0.0.1", gomock.Any()).
116 Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
117 testClient.MockReleases.EXPECT().
118 GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).
119 Return(nil, notFoundResponse, errors.New("not found"))
121 exec := cmdtest.SetupCmdForTest(
122 t,
123 NewCmdCreate,
124 false,
125 cmdtest.WithGitLabClient(testClient.Client),
126 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
127 )
129 _, err := exec(`0.0.1 --notes "test release" --released-at "not-a-valid-timestamp-that-is-long"`)
131 require.Error(t, err)
132 assert.Contains(t, err.Error(), "cannot parse")
135func TestReleaseCreate_ReturnsTagTransportError(t *testing.T) {
136 t.Parallel()
138 testClient := gitlabtesting.NewTestClient(t)
139 testClient.MockTags.EXPECT().
140 GetTag("OWNER/REPO", "0.0.1", gomock.Any()).
141 Return(nil, nil, errors.New("network unavailable"))
143 exec := cmdtest.SetupCmdForTest(
144 t,
145 NewCmdCreate,
146 false,
147 cmdtest.WithGitLabClient(testClient.Client),
148 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
149 )
151 _, err := exec(`0.0.1 --notes "test release"`)
153 require.ErrorContains(t, err, "network unavailable")
156func TestReleaseCreateWithFiles(t *testing.T) {
157 // NOTE: This test cannot use t.Parallel() because it uses t.Setenv().
158 t.Setenv("CI_DEFAULT_BRANCH", "main")
160 tests := []struct {
161 name string
162 cli string
164 wantType bool
165 expectedType gitlab.LinkTypeValue
166 }{
167 {
168 name: "when a release is created and a file is uploaded using filename only",
169 cli: "0.0.1 --notes \"test release\" testdata/test_file.txt",
171 wantType: false,
172 },
173 {
174 name: "when a release is created and a filename is uploaded with display name and type",
175 cli: "0.0.1 --notes \"test release\" testdata/test_file.txt#test_file#other",
177 wantType: true,
178 expectedType: gitlab.OtherLinkType,
179 },
180 {
181 name: "when a release is created and a filename is uploaded with a type",
182 cli: "0.0.1 --notes \"test release\" testdata/test_file.txt##package",
184 wantType: true,
185 expectedType: gitlab.PackageLinkType,
186 },
187 }
189 for _, tc := range tests {
190 t.Run(tc.name, func(t *testing.T) {
191 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
193 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
195 // Tag exists
196 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
198 // Release doesn't exist
199 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
201 // Mock UploadProjectMarkdown for file upload
202 uploadCall := testClient.MockProjectMarkdownUploads.EXPECT().
203 UploadProjectMarkdown("OWNER/REPO", gomock.Any(), "test_file.txt", gomock.Any()).
204 Return(&gitlab.ProjectMarkdownUploadedFile{
205 Alt: "test_file",
206 URL: "/uploads/66dbcd21ec5d24ed6ea225176098d52b/test_file.txt",
207 FullPath: "/namespace1/project1/uploads/66dbcd21ec5d24ed6ea225176098d52b/test_file.txt",
208 Markdown: "![test_file](/uploads/66dbcd21ec5d24ed6ea225176098d52b/test_file.txt)",
209 }, nil, nil)
211 // The file link goes in CreateRelease. Any CreateReleaseLink call fails the test.
212 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
213 After(uploadCall.Call).
214 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
215 assert.Equal(t, "0.0.1", *opts.TagName)
216 require.NotNil(t, opts.Assets)
217 require.Len(t, opts.Assets.Links, 1)
218 link := opts.Assets.Links[0]
219 assert.Equal(t, "https://gitlab.com/namespace1/project1/uploads/66dbcd21ec5d24ed6ea225176098d52b/test_file.txt", *link.URL)
220 assert.Equal(t, "/test_file.txt", *link.DirectAssetPath)
221 if tc.wantType {
222 require.NotNil(t, link.LinkType)
223 assert.Equal(t, tc.expectedType, *link.LinkType)
224 } else {
225 assert.Nil(t, link.LinkType)
226 }
228 return &gitlab.Release{
229 Name: "test_release",
230 TagName: "0.0.1",
231 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
232 Assets: gitlab.ReleaseAssets{
233 Links: []*gitlab.ReleaseLink{{
234 ID: 2,
235 Name: "test_file.txt",
236 URL: "https://gitlab.com/namespace1/project1/uploads/66dbcd21ec5d24ed6ea225176098d52b/test_file.txt",
237 DirectAssetURL: "https://gitlab.example.com/mynamespace/hello/-/releases/0.0.1/downloads/test_file.txt",
238 LinkType: gitlab.OtherLinkType,
239 }},
240 },
241 }, nil, nil
242 })
244 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
245 cmdtest.WithGitLabClient(testClient.Client),
246 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
247 )
249 output, err := exec(tc.cli)
251 if assert.NoErrorf(t, err, "error running command `create %s`: %v", tc.cli, err) {
252 assert.Contains(t, output.String(), `• Validating tag 0.0.1
253• Creating or updating release repo=OWNER/REPO tag=0.0.1
254• Uploading to release file=testdata/test_file.txt name=test_file.txt
255✓ Release created: url=https://gitlab.com/OWNER/REPO/-/releases/0.0.1
256✓ Added release asset name=test_file.txt url=https://gitlab.example.com/mynamespace/hello/-/releases/0.0.1/downloads/test_file.txt
257✓ Release succeeded after`)
258 assert.Empty(t, output.Stderr())
259 }
260 })
261 }
264func TestReleaseCreate_WithAssetsLinksJSON(t *testing.T) {
265 // NOTE: This test cannot use t.Parallel() because it uses t.Setenv().
266 t.Setenv("CI_DEFAULT_BRANCH", "main")
268 tests := []struct {
269 name string
270 cli string
271 expectedOutput string
272 wantConflict bool
273 }{
274 {
275 name: "with direct_asset_path",
276 cli: `0.0.1 --notes "test release" --assets-links='[{"name": "any-name", "url": "https://example.com/any-asset-url", "direct_asset_path": "/any-path"}]'`,
277 expectedOutput: `• Validating tag 0.0.1
278• Creating or updating release repo=OWNER/REPO tag=0.0.1
279✓ Release created: url=https://gitlab.com/OWNER/REPO/-/releases/0.0.1
280✓ Added release asset name=any-name url=https://gitlab.example.com/OWNER/REPO/releases/0.0.1/downloads/any-path
281✓ Release succeeded after`,
282 },
283 {
284 name: "with filepath aliased to direct_asset_path",
285 cli: `0.0.1 --notes "test release" --assets-links='[{"name": "any-name", "url": "https://example.com/any-asset-url", "filepath": "/any-path"}]'`,
286 expectedOutput: `• Validating tag 0.0.1
287• Creating or updating release repo=OWNER/REPO tag=0.0.1
288✓ Release created: url=https://gitlab.com/OWNER/REPO/-/releases/0.0.1
289✓ Added release asset name=any-name url=https://gitlab.example.com/OWNER/REPO/releases/0.0.1/downloads/any-path
290 ! Aliased deprecated ` + "`filepath`" + ` field to ` + "`direct_asset_path`" + `. Replace ` + "`filepath`" + ` with ` + "`direct_asset_path`" + ` name=any-name
291✓ Release succeeded after`,
292 },
293 {
294 name: "with both filepath and direct_asset_path",
295 cli: `0.0.1 --notes "test release" testdata/test_file.txt --assets-links='[{"name": "any-name", "url": "https://example.com/any-asset-url", "filepath": "/any-path", "direct_asset_path": "/any-path"}]'`,
296 wantConflict: true,
297 },
298 }
300 for _, tt := range tests {
301 t.Run(tt.name, func(t *testing.T) {
302 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
304 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
306 // Tag exists
307 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
309 // Release doesn't exist
310 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
312 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
313 cmdtest.WithGitLabClient(testClient.Client),
314 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
315 )
317 if tt.wantConflict {
318 // No upload or CreateRelease expectation: either call fails the test.
319 _, err := exec(tt.cli)
321 var conflictErr *upload.ConflictDirectAssetPathError
322 require.ErrorAs(t, err, &conflictErr)
323 return
324 }
326 // The links go in CreateRelease. Any CreateReleaseLink call fails the test.
327 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
328 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
329 require.NotNil(t, opts.Assets)
330 require.Len(t, opts.Assets.Links, 1)
331 link := opts.Assets.Links[0]
332 assert.Equal(t, "any-name", *link.Name)
333 assert.Equal(t, "https://example.com/any-asset-url", *link.URL)
334 require.NotNil(t, link.DirectAssetPath)
335 assert.Equal(t, "/any-path", *link.DirectAssetPath)
336 assert.Nil(t, link.FilePath)
338 return &gitlab.Release{
339 Name: "test_release",
340 TagName: "0.0.1",
341 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
342 Assets: gitlab.ReleaseAssets{
343 Links: []*gitlab.ReleaseLink{{
344 ID: 1,
345 Name: "any-name",
346 URL: "https://example.com/any-asset-url",
347 DirectAssetURL: "https://gitlab.example.com/OWNER/REPO/releases/0.0.1/downloads/any-path",
348 LinkType: gitlab.OtherLinkType,
349 }},
350 },
351 }, nil, nil
352 })
354 output, err := exec(tt.cli)
356 if assert.NoErrorf(t, err, "error running command `create %s`: %v", tt.cli, err) {
357 assert.Contains(t, output.String(), tt.expectedOutput)
358 assert.Empty(t, output.Stderr())
359 }
360 })
361 }
364func TestReleaseCreate_FilesAndAssetsLinksJSON(t *testing.T) {
365 t.Setenv("CI_DEFAULT_BRANCH", "main")
367 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
368 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
370 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
371 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
373 uploadCall := testClient.MockProjectMarkdownUploads.EXPECT().
374 UploadProjectMarkdown("OWNER/REPO", gomock.Any(), "test_file.txt", gomock.Any()).
375 Return(&gitlab.ProjectMarkdownUploadedFile{FullPath: "/-/project/1/uploads/abc/test_file.txt"}, nil, nil)
377 // Both links go in CreateRelease. Any CreateReleaseLink call fails the test.
378 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
379 After(uploadCall.Call).
380 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
381 require.NotNil(t, opts.Assets)
382 require.Len(t, opts.Assets.Links, 2)
383 assert.Equal(t, "any-name", *opts.Assets.Links[0].Name)
384 assert.Equal(t, "https://example.com/any-asset-url", *opts.Assets.Links[0].URL)
385 assert.Equal(t, "test_file.txt", *opts.Assets.Links[1].Name)
386 assert.Equal(t, "https://gitlab.com/-/project/1/uploads/abc/test_file.txt", *opts.Assets.Links[1].URL)
388 return &gitlab.Release{
389 Name: "test_release",
390 TagName: "0.0.1",
391 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
392 }, nil, nil
393 })
395 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
396 cmdtest.WithGitLabClient(testClient.Client),
397 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
398 )
400 output, err := exec(`0.0.1 --notes "test release" testdata/test_file.txt --assets-links='[{"name": "any-name", "url": "https://example.com/any-asset-url"}]'`)
402 require.NoError(t, err)
403 assert.Contains(t, output.String(), "Release created:")
404 assert.Empty(t, output.Stderr())
407func TestReleaseCreate_UpdateWithAssetsLinksJSON(t *testing.T) {
408 t.Parallel()
410 testClient := gitlabtesting.NewTestClient(t)
412 okResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusOK}}
413 existingRelease := &gitlab.Release{
414 Name: "0.0.1",
415 TagName: "0.0.1",
416 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
417 }
419 // Tag exists
420 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
422 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(existingRelease, okResponse, nil)
424 // UpdateRelease has no assets option. Any CreateRelease call fails the test.
425 testClient.MockReleases.EXPECT().UpdateRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(existingRelease, okResponse, nil)
427 testClient.MockReleaseLinks.EXPECT().
428 CreateReleaseLink("OWNER/REPO", "0.0.1", gomock.Any(), gomock.Any()).
429 DoAndReturn(func(pid any, tagName string, opts *gitlab.CreateReleaseLinkOptions, options ...gitlab.RequestOptionFunc) (*gitlab.ReleaseLink, *gitlab.Response, error) {
430 assert.Equal(t, "any-name", *opts.Name)
431 assert.Equal(t, "https://example.com/any-asset-url", *opts.URL)
432 require.NotNil(t, opts.DirectAssetPath)
433 assert.Equal(t, "/any-path", *opts.DirectAssetPath)
435 return &gitlab.ReleaseLink{
436 ID: 1,
437 Name: "any-name",
438 URL: "https://example.com/any-asset-url",
439 DirectAssetURL: "https://gitlab.example.com/OWNER/REPO/releases/0.0.1/downloads/any-path",
440 }, nil, nil
441 }).
442 Times(1)
444 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
445 cmdtest.WithGitLabClient(testClient.Client),
446 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
447 )
449 output, err := exec(`0.0.1 --notes "test release" --assets-links='[{"name": "any-name", "url": "https://example.com/any-asset-url", "direct_asset_path": "/any-path"}]'`)
450 require.NoError(t, err)
451 assert.Contains(t, output.String(), "✓ Release updated")
452 assert.Contains(t, output.String(), "✓ Added release asset\tname=any-name url=https://gitlab.example.com/OWNER/REPO/releases/0.0.1/downloads/any-path")
453 assert.Empty(t, output.Stderr())
456func TestReleaseCreate_InvalidAssetsLinksJSON(t *testing.T) {
457 t.Parallel()
459 tests := []struct {
460 name string
461 assetsLinks string
462 wantErr string
463 }{
464 {
465 name: "only a null link",
466 assetsLinks: `[null]`,
467 wantErr: "failed to parse JSON string: the asset link at index 0 is null",
468 },
469 {
470 name: "a null link after a valid one",
471 assetsLinks: `[{"name": "any-name", "url": "https://example.com/any-asset-url"}, null]`,
472 wantErr: "failed to parse JSON string: the asset link at index 1 is null",
473 },
474 {
475 name: "malformed JSON",
476 assetsLinks: `[{"name": "any-name"`,
477 wantErr: "failed to parse JSON string: unexpected end of JSON input",
478 },
479 }
481 for _, tt := range tests {
482 t.Run(tt.name, func(t *testing.T) {
483 t.Parallel()
485 // No expectations: the links are rejected before any request is sent.
486 testClient := gitlabtesting.NewTestClient(t)
488 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
489 cmdtest.WithGitLabClient(testClient.Client),
490 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
491 )
493 _, err := exec(`0.0.1 --notes "test release" --assets-links='` + tt.assetsLinks + `'`)
495 require.EqualError(t, err, tt.wantErr)
496 })
497 }
500func TestReleaseCreateWithPublishToCatalog(t *testing.T) {
501 // This test uses httptest.NewServer because the catalog publish API uses raw HTTP
502 // via client.Do() rather than a GitLab client-go service interface.
504 tests := []struct {
505 name string
506 cli string
508 wantOutput string
509 wantBody string
510 wantErr bool
511 errMsg string
512 }{
513 {
514 name: "with version",
515 cli: "0.0.1 --notes \"test release\" --publish-to-catalog",
516 wantBody: `{
517 "version": "0.0.1",
518 "metadata": {
519 "components": [
520 {
521 "component_type": "template",
522 "name": "component-1",
523 "spec": {
524 "inputs": {
525 "compiler": {
526 "default": "gcc"
527 }
528 }
529 }
530 },
531 {
532 "component_type": "template",
533 "name": "component-2",
534 "spec": null
535 },
536 {
537 "component_type": "template",
538 "name": "component-3",
539 "spec": {
540 "inputs": {
541 "test_framework": {
542 "default": "unittest"
543 }
544 }
545 }
546 }
547 ]
548 }
549 }`,
550 wantOutput: `• Publishing release tag=0.0.1 to the GitLab CI/CD catalog for repo=OWNER/REPO...
551✓ Release published: url=https://gitlab.example.com/explore/catalog/my-namespace/my-component-project`,
552 },
553 }
555 originalWd, err := os.Getwd()
556 require.NoError(t, err)
558 t.Chdir(filepath.Join(originalWd, "..", "..", "project", "publish", "catalog", "testdata", "test-repo"))
560 for _, tc := range tests {
561 t.Run(tc.name, func(t *testing.T) {
562 // Create a test server that handles both release APIs and catalog publish
563 testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
564 switch {
565 case r.Method == http.MethodGet && r.URL.Path == "/api/v4/projects/OWNER/REPO/repository/tags/0.0.1":
566 // Tag exists
567 w.WriteHeader(http.StatusOK)
568 _, _ = w.Write([]byte(`{"name": "0.0.1"}`))
570 case r.Method == http.MethodGet && r.URL.Path == "/api/v4/projects/OWNER/REPO/releases/0.0.1":
571 w.WriteHeader(http.StatusNotFound)
572 _, _ = w.Write([]byte(`{"message":"404 Not Found"}`))
574 case r.Method == http.MethodPost && r.URL.Path == "/api/v4/projects/OWNER/REPO/releases":
575 w.WriteHeader(http.StatusCreated)
576 _, _ = w.Write([]byte(`{
577 "name": "test_release",
578 "tag_name": "0.0.1",
579 "description": "bugfix release",
580 "created_at": "2023-01-19T02:58:32.622Z",
581 "released_at": "2023-01-19T02:58:32.622Z",
582 "upcoming_release": false,
583 "tag_path": "/OWNER/REPO/-/tags/0.0.1",
584 "_links": {
585 "self": "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"
586 }
587 }`))
589 case r.Method == http.MethodPost && r.URL.Path == "/api/v4/projects/OWNER/REPO/catalog/publish":
590 if tc.wantBody != "" {
591 var reqBody, expectedBody map[string]any
592 err := json.NewDecoder(r.Body).Decode(&reqBody)
593 assert.NoError(t, err)
594 err = json.Unmarshal([]byte(tc.wantBody), &expectedBody)
595 assert.NoError(t, err)
597 reqBodyJSON, _ := json.Marshal(reqBody)
598 expectedBodyJSON, _ := json.Marshal(expectedBody)
599 assert.JSONEq(t, string(expectedBodyJSON), string(reqBodyJSON))
600 }
602 w.WriteHeader(http.StatusOK)
603 _, _ = w.Write([]byte(`{
604 "catalog_url": "https://gitlab.example.com/explore/catalog/my-namespace/my-component-project"
605 }`))
607 default:
608 t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
609 w.WriteHeader(http.StatusNotFound)
610 }
611 }))
612 defer testServer.Close()
614 // Create a GitLab client with the test server's URL
615 gitlabClient, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(testServer.URL+"/api/v4"))
616 require.NoError(t, err)
618 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
619 cmdtest.WithGitLabClient(gitlabClient),
620 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
621 )
623 output, err := exec(tc.cli)
625 if tc.wantErr {
626 require.Error(t, err)
627 assert.Equal(t, tc.errMsg, err.Error())
628 } else {
629 require.NoError(t, err)
630 assert.Contains(t, output.String(), tc.wantOutput)
631 }
632 })
633 }
636func TestReleaseCreate_NoUpdate(t *testing.T) {
637 t.Setenv("CI_DEFAULT_BRANCH", "main")
639 t.Run("when release doesn't exist with --no-update flag", func(t *testing.T) {
640 tc := gitlabtesting.NewTestClient(t)
642 exec := cmdtest.SetupCmdForTest(
643 t,
644 NewCmdCreate,
645 false,
646 cmdtest.WithGitLabClient(tc.Client),
647 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
648 )
650 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
652 // Tag exists, so no need to get default branch
653 tc.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
654 tc.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
655 tc.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).Return(&gitlab.Release{
656 Name: "test_release",
657 TagName: "0.0.1",
658 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
659 }, nil, nil)
661 output, err := exec("0.0.1 --notes \"test release\" --no-update")
662 require.NoError(t, err)
663 assert.Contains(t, output.String(), "Release created:")
664 })
666 t.Run("when release exists with --no-update flag", func(t *testing.T) {
667 tc := gitlabtesting.NewTestClient(t)
669 exec := cmdtest.SetupCmdForTest(
670 t,
671 NewCmdCreate,
672 false,
673 cmdtest.WithGitLabClient(tc.Client),
674 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
675 )
677 okResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusOK}}
679 // Tag exists
680 tc.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
681 // Release exists
682 tc.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Release{
683 Name: "test_release",
684 TagName: "0.0.1",
685 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
686 }, okResponse, nil)
688 _, err := exec("0.0.1 --notes \"test release\" --no-update")
689 require.Error(t, err)
690 assert.Contains(t, err.Error(), "release for tag \"0.0.1\" already exists and --no-update flag was specified")
691 })
694func TestReleaseCreate_MilestoneClosing(t *testing.T) {
695 t.Setenv("CI_DEFAULT_BRANCH", "main")
697 t.Run("successfully closes milestone after release", func(t *testing.T) {
698 testClient := gitlabtesting.NewTestClient(t)
700 exec := cmdtest.SetupCmdForTest(
701 t,
702 NewCmdCreate,
703 false,
704 cmdtest.WithGitLabClient(testClient.Client),
705 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
706 )
708 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
710 // Tag exists
711 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
713 // Release doesn't exist
714 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
716 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).Return(&gitlab.Release{
717 Name: "0.0.1",
718 TagName: "0.0.1",
719 Description: "Release with milestone",
720 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
721 }, nil, nil)
723 // List milestones to find the one to close
724 testClient.MockMilestones.EXPECT().ListMilestones("OWNER/REPO", gomock.Any()).Return([]*gitlab.Milestone{
725 {
726 ID: 1,
727 IID: 1,
728 Title: "v1.0",
729 State: "active",
730 },
731 }, nil, nil)
733 // Update milestone to closed state
734 testClient.MockMilestones.EXPECT().UpdateMilestone("OWNER/REPO", int64(1), gomock.Any()).Return(&gitlab.Milestone{
735 ID: 1,
736 IID: 1,
737 Title: "v1.0",
738 State: "closed",
739 }, nil, nil)
741 output, err := exec("0.0.1 --notes \"test release\" --milestone 'v1.0'")
743 require.NoError(t, err)
744 assert.Contains(t, output.String(), `• Validating tag 0.0.1
745• Creating or updating release repo=OWNER/REPO tag=0.0.1
746✓ Release created: url=https://gitlab.com/OWNER/REPO/-/releases/0.0.1
747✓ Closed milestone "v1.0"`)
748 })
750 t.Run("skips milestone closing when --no-close-milestone is set", func(t *testing.T) {
751 testClient := gitlabtesting.NewTestClient(t)
753 exec := cmdtest.SetupCmdForTest(
754 t,
755 NewCmdCreate,
756 false,
757 cmdtest.WithGitLabClient(testClient.Client),
758 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
759 )
761 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
763 // Tag exists
764 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
766 // Release doesn't exist
767 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
769 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).Return(&gitlab.Release{
770 Name: "0.0.1",
771 TagName: "0.0.1",
772 Description: "Release with milestone",
773 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
774 }, nil, nil)
776 // No milestone API calls expected when --no-close-milestone is set
778 output, err := exec("0.0.1 --notes \"test release\" --milestone 'v1.0' --no-close-milestone")
780 require.NoError(t, err)
781 assert.Contains(t, output.String(), `• Validating tag 0.0.1
782• Creating or updating release repo=OWNER/REPO tag=0.0.1
783✓ Release created: url=https://gitlab.com/OWNER/REPO/-/releases/0.0.1
784✓ Skipping closing milestones`)
785 })
787 for _, tt := range []struct {
788 name string
789 status int
790 authSource gitlab.AuthSource
791 hint bool
792 }{
793 {name: "job token unauthorized", status: http.StatusUnauthorized, authSource: gitlab.JobTokenAuthSource{Token: "job-token"}, hint: true},
794 {name: "job token forbidden", status: http.StatusForbidden, authSource: gitlab.JobTokenAuthSource{Token: "job-token"}, hint: true},
795 {name: "job token server error", status: http.StatusInternalServerError, authSource: gitlab.JobTokenAuthSource{Token: "job-token"}},
796 {name: "access token unauthorized", status: http.StatusUnauthorized, authSource: gitlab.AccessTokenAuthSource{Token: "pat"}},
797 {name: "access token forbidden", status: http.StatusForbidden, authSource: gitlab.AccessTokenAuthSource{Token: "pat"}},
798 } {
799 t.Run("explains failed milestone lookup/"+tt.name, func(t *testing.T) {
800 testClient := gitlabtesting.NewTestClient(t)
802 exec := cmdtest.SetupCmdForTest(
803 t,
804 NewCmdCreate,
805 false,
806 cmdtest.WithGitLabClient(testClient.Client),
807 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, tt.authSource, glinstance.DefaultHostname)),
808 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
809 )
811 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
812 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
813 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
814 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).Return(&gitlab.Release{
815 TagName: "0.0.1",
816 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
817 }, nil, nil)
818 testClient.MockMilestones.EXPECT().ListMilestones("OWNER/REPO", gomock.Any()).
819 Return(nil, nil, &gitlab.ErrorResponse{StatusCode: tt.status, Message: http.StatusText(tt.status)})
821 output, err := exec("0.0.1 --notes \"test release\" --milestone 'v1.0'")
823 require.NoError(t, err)
824 if tt.hint {
825 assert.Contains(t, output.Stderr(), "A CI_JOB_TOKEN cannot access the Milestones API")
826 assert.Contains(t, output.Stderr(), "--no-close-milestone")
827 } else {
828 assert.NotContains(t, output.Stderr(), "CI_JOB_TOKEN")
829 }
830 })
831 }
834func TestReleaseCreate_WithoutNotes(t *testing.T) {
835 t.Setenv("CI_DEFAULT_BRANCH", "main")
837 t.Run("create release without notes in non-interactive mode", func(t *testing.T) {
838 testClient := gitlabtesting.NewTestClient(t)
840 exec := cmdtest.SetupCmdForTest(
841 t,
842 NewCmdCreate,
843 false,
844 cmdtest.WithGitLabClient(testClient.Client),
845 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
846 )
848 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
850 // Tag exists
851 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
853 // Release doesn't exist
854 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
856 // Create release without description
857 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
858 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
859 // Description should not be set (or be empty)
860 if opts.Description != nil {
861 assert.Empty(t, *opts.Description)
862 }
863 return &gitlab.Release{
864 Name: "0.0.1",
865 TagName: "0.0.1",
866 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
867 }, nil, nil
868 })
870 output, err := exec("0.0.1")
871 require.NoError(t, err)
872 assert.Contains(t, output.String(), "Release created:")
873 })
875 t.Run("update release without notes in non-interactive mode", func(t *testing.T) {
876 testClient := gitlabtesting.NewTestClient(t)
878 exec := cmdtest.SetupCmdForTest(
879 t,
880 NewCmdCreate,
881 false,
882 cmdtest.WithGitLabClient(testClient.Client),
883 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
884 )
886 okResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusOK}}
888 // Tag exists
889 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
891 // Release exists
892 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Release{
893 Name: "0.0.1",
894 TagName: "0.0.1",
895 Description: "Original description",
896 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
897 }, okResponse, nil)
899 // Update release - verifying we can update without providing notes and preserve existing description
900 testClient.MockReleases.EXPECT().UpdateRelease("OWNER/REPO", "0.0.1", gomock.Any()).
901 DoAndReturn(func(pid any, tagName string, opts *gitlab.UpdateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
902 require.NotNil(t, opts.Description)
903 assert.Equal(t, "Original description", *opts.Description)
904 require.NotNil(t, opts.Name)
905 assert.Equal(t, "Updated Name", *opts.Name)
906 return &gitlab.Release{
907 Name: "Updated Name",
908 TagName: "0.0.1",
909 Description: "Original description", // Keep original
910 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
911 }, nil, nil
912 })
914 // Update without providing notes - just update the name
915 output, err := exec("0.0.1 --name 'Updated Name'")
916 require.NoError(t, err)
917 assert.Contains(t, output.String(), "Release updated")
918 })
921func TestReleaseCreate_DefaultBranchDetectionForRef(t *testing.T) {
922 t.Setenv("CI_DEFAULT_BRANCH", "")
924 t.Run("use default branch from project API when available", func(t *testing.T) {
925 tc := gitlabtesting.NewTestClient(t)
927 exec := cmdtest.SetupCmdForTest(
928 t,
929 NewCmdCreate,
930 false,
931 cmdtest.WithGitLabClient(tc.Client),
932 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
933 )
935 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
936 tc.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
937 tc.MockProjects.EXPECT().GetProject("OWNER/REPO", gomock.Any()).Return(&gitlab.Project{DefaultBranch: "some-default-branch"}, nil, nil)
938 tc.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
939 tc.MockReleases.EXPECT().CreateRelease("OWNER/REPO", &gitlab.CreateReleaseOptions{
940 Name: new("0.0.1"),
941 TagName: new("0.0.1"),
942 Description: new("test release"),
943 Ref: new("some-default-branch"),
944 }).Return(&gitlab.Release{}, nil, nil)
946 _, err := exec("0.0.1 --notes \"test release\"")
947 require.NoError(t, err)
948 })
950 t.Run("use default branch from environment if available and project API not available", func(t *testing.T) {
951 t.Setenv("CI_DEFAULT_BRANCH", "some-default-branch")
953 tc := gitlabtesting.NewTestClient(t)
955 exec := cmdtest.SetupCmdForTest(
956 t,
957 NewCmdCreate,
958 false,
959 cmdtest.WithGitLabClient(tc.Client),
960 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
961 )
963 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
964 tc.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
965 tc.MockProjects.EXPECT().GetProject("OWNER/REPO", gomock.Any()).Return(nil, nil, errors.New("forbidden"))
966 tc.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
967 tc.MockReleases.EXPECT().CreateRelease("OWNER/REPO", &gitlab.CreateReleaseOptions{
968 Name: new("0.0.1"),
969 TagName: new("0.0.1"),
970 Description: new("test release"),
971 Ref: new("some-default-branch"),
972 }).Return(&gitlab.Release{}, nil, nil)
974 _, err := exec("0.0.1 --notes \"test release\"")
975 require.NoError(t, err)
976 })
978 t.Run("no explicit ref if default branch not in environment and project API not available", func(t *testing.T) {
979 tc := gitlabtesting.NewTestClient(t)
981 exec := cmdtest.SetupCmdForTest(
982 t,
983 NewCmdCreate,
984 false,
985 cmdtest.WithGitLabClient(tc.Client),
986 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
987 )
989 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
990 tc.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
991 tc.MockProjects.EXPECT().GetProject("OWNER/REPO", gomock.Any()).Return(nil, nil, errors.New("forbidden"))
992 tc.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
993 tc.MockReleases.EXPECT().CreateRelease("OWNER/REPO", &gitlab.CreateReleaseOptions{
994 Name: new("0.0.1"),
995 TagName: new("0.0.1"),
996 Description: new("test release"),
997 Ref: nil,
998 }).Return(&gitlab.Release{}, nil, nil)
1000 _, err := exec("0.0.1 --notes \"test release\"")
1001 require.NoError(t, err)
1002 })
1005func TestReleaseCreate_UsePackageRegistryEnvVar(t *testing.T) {
1006 // NOTE: This test cannot use t.Parallel() because it uses t.Setenv().
1007 t.Setenv("CI_DEFAULT_BRANCH", "main")
1008 t.Setenv("GITLAB_RELEASE_ASSETS_USE_PACKAGE_REGISTRY", "true")
1010 t.Run("when env var is set, files are uploaded to the package registry instead of project markdown", func(t *testing.T) {
1011 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
1012 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
1014 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
1015 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
1017 // With the env var set, the file must go through the generic package registry,
1018 // not through UploadProjectMarkdown. If the bug is present (err != nil instead of
1019 // err == nil), usePackageRegistry stays false and UploadProjectMarkdown is called
1020 // instead — causing this expectation to fail as "expected call not received".
1021 testClient.MockGenericPackages.EXPECT().
1022 PublishPackageFile("OWNER/REPO", "release-assets", "0.0.1", "test_file.txt", gomock.Any(), gomock.Any(), gomock.Any()).
1023 Return(&gitlab.GenericPackagesFile{}, nil, nil)
1025 testClient.MockGenericPackages.EXPECT().
1026 FormatPackageURL("OWNER/REPO", "release-assets", "0.0.1", "test_file.txt").
1027 Return("/api/v4/projects/OWNER/REPO/packages/generic/release-assets/0.0.1/test_file.txt", nil)
1029 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
1030 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
1031 require.NotNil(t, opts.Assets)
1032 require.Len(t, opts.Assets.Links, 1)
1033 assert.Contains(t, *opts.Assets.Links[0].URL, "/packages/generic/release-assets/0.0.1/test_file.txt")
1035 return &gitlab.Release{
1036 Name: "test_release",
1037 TagName: "0.0.1",
1038 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
1039 }, nil, nil
1040 })
1042 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
1043 cmdtest.WithGitLabClient(testClient.Client),
1044 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
1047 output, err := exec(`0.0.1 --notes "test release" testdata/test_file.txt`)
1049 require.NoError(t, err)
1050 assert.Contains(t, output.String(), "Release created:")
1051 assert.Empty(t, output.Stderr())
1052 })
1055func TestReleaseCreate_NotesAndNotesFile(t *testing.T) {
1056 t.Setenv("CI_DEFAULT_BRANCH", "main")
1058 tests := []struct {
1059 name string
1060 cli string
1061 fileContent string
1062 wantDescription string
1063 wantWarning bool
1064 }{
1066 name: "both flags warn and use inline notes without reading file",
1067 cli: `0.0.1 --notes "inline release notes" --notes-file missing.md`,
1068 wantDescription: "inline release notes",
1069 wantWarning: true,
1070 },
1072 name: "inline notes alone do not warn",
1073 cli: `0.0.1 --notes "inline release notes"`,
1074 wantDescription: "inline release notes",
1075 },
1077 name: "notes file alone does not warn",
1078 cli: `0.0.1 --notes-file notes.md`,
1079 fileContent: "release notes from file",
1080 wantDescription: "release notes from file",
1081 },
1084 for _, tt := range tests {
1085 t.Run(tt.name, func(t *testing.T) {
1086 t.Chdir(t.TempDir())
1087 if tt.fileContent != "" {
1088 require.NoError(t, os.WriteFile("notes.md", []byte(tt.fileContent), 0o600))
1091 testClient := gitlabtesting.NewTestClient(t)
1092 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
1093 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).
1094 Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
1095 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).
1096 Return(nil, notFoundResponse, errors.New("not found"))
1097 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
1098 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
1099 require.NotNil(t, opts.Description)
1100 assert.Equal(t, tt.wantDescription, *opts.Description)
1101 return &gitlab.Release{
1102 Name: "test_release",
1103 TagName: "0.0.1",
1104 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
1105 }, nil, nil
1106 })
1108 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
1109 cmdtest.WithGitLabClient(testClient.Client),
1110 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
1112 output, err := exec(tt.cli)
1113 require.NoError(t, err)
1114 assert.Contains(t, output.String(), "Release created:")
1115 if tt.wantWarning {
1116 assert.Contains(t, output.Stderr(), "--notes and --notes-file were both given")
1117 assert.Contains(t, output.Stderr(), "using --notes and ignoring --notes-file")
1118 } else {
1119 assert.Empty(t, output.Stderr())
1121 })
1125func TestReleaseCreate_ExperimentalNotes(t *testing.T) {
1126 t.Setenv("CI_DEFAULT_BRANCH", "main")
1128 tests := []struct {
1129 name string
1130 cli string
1131 files map[string]string
1132 wantErr bool
1133 errMsg string
1134 setupMocks bool
1135 expectedDescription string
1136 }{
1138 name: "when experimental notes is used with notes flag",
1139 cli: `0.0.1 --experimental-notes-text-or-file "test.md" --notes "test"`,
1140 wantErr: true,
1141 errMsg: "if any flags in the group [experimental-notes-text-or-file notes] are set none of the others can be; [experimental-notes-text-or-file notes] were all set",
1142 setupMocks: false,
1143 },
1145 name: "when experimental notes is used with notes-file flag",
1146 cli: `0.0.1 --experimental-notes-text-or-file "test.md" --notes-file "other.md"`,
1147 wantErr: true,
1148 errMsg: "if any flags in the group [experimental-notes-text-or-file notes-file] are set none of the others can be; [experimental-notes-text-or-file notes-file] were all set",
1149 setupMocks: false,
1150 },
1152 name: "when experimental notes points to existing file",
1153 cli: `0.0.1 --experimental-notes-text-or-file "test.md"`,
1154 files: map[string]string{
1155 "test.md": "# Test Release\nThis is a test release.",
1156 },
1157 setupMocks: true,
1158 expectedDescription: "# Test Release\nThis is a test release.",
1159 },
1161 name: "when experimental notes has non-existent file and falls back to text",
1162 cli: `0.0.1 --experimental-notes-text-or-file "This is plain text"`,
1163 setupMocks: true,
1164 expectedDescription: "This is plain text",
1165 },
1167 name: "when experimental notes contains spaces, treats as text",
1168 cli: `0.0.1 --experimental-notes-text-or-file "This contains spaces.md"`,
1169 setupMocks: true,
1170 expectedDescription: "This contains spaces.md",
1171 },
1173 name: "when experimental notes has leading/trailing spaces",
1174 cli: `0.0.1 --experimental-notes-text-or-file " notes.md "`,
1175 setupMocks: true,
1176 expectedDescription: " notes.md ",
1177 },
1180 for _, tt := range tests {
1181 t.Run(tt.name, func(t *testing.T) {
1182 t.Chdir(t.TempDir())
1184 for filename, content := range tt.files {
1185 err := os.WriteFile(filename, []byte(content), 0o600)
1186 require.NoError(t, err)
1189 testClient := gitlabtesting.NewTestClient(t)
1191 if tt.setupMocks {
1192 notFoundResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusNotFound}}
1194 // Tag exists
1195 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "0.0.1", gomock.Any()).Return(&gitlab.Tag{Name: "0.0.1"}, nil, nil)
1197 // Release doesn't exist
1198 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "0.0.1", gomock.Any()).Return(nil, notFoundResponse, errors.New("not found"))
1200 // Create release and verify description
1201 testClient.MockReleases.EXPECT().CreateRelease("OWNER/REPO", gomock.Any()).
1202 DoAndReturn(func(pid any, opts *gitlab.CreateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
1203 if tt.expectedDescription != "" {
1204 require.NotNil(t, opts.Description)
1205 assert.Equal(t, tt.expectedDescription, *opts.Description)
1207 return &gitlab.Release{
1208 Name: "test_release",
1209 TagName: "0.0.1",
1210 Links: gitlab.ReleaseLinks{Self: "https://gitlab.com/OWNER/REPO/-/releases/0.0.1"},
1211 }, nil, nil
1212 })
1215 exec := cmdtest.SetupCmdForTest(t, NewCmdCreate, false,
1216 cmdtest.WithGitLabClient(testClient.Client),
1217 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
1220 output, err := exec(tt.cli)
1222 if tt.wantErr {
1223 require.Error(t, err)
1224 assert.Equal(t, tt.errMsg, err.Error())
1225 } else {
1226 require.NoErrorf(t, err, "error running command `create %s`: %v", tt.cli, err)
1227 assert.Contains(t, output.String(), "✓ Release created:")
1228 assert.Empty(t, output.Stderr())
1230 })
1234func TestReleaseCreate_UpdatePreservesExistingNotesAndName(t *testing.T) {
1235 releasedAtTime, err := time.Parse(time.RFC3339, "2026-10-30T10:00:00Z")
1236 require.NoError(t, err)
1238 emptyName := ""
1240 tests := []struct {
1241 name string
1242 cli string
1243 existingName *string
1244 wantDescription string
1245 wantName string
1246 wantReleasedAt *time.Time
1247 }{
1249 name: "updating without notes or name preserves existing values",
1250 cli: "1.0.0 --released-at '2026-10-30T10:00:00Z'",
1251 wantDescription: "Existing release description",
1252 wantName: "Existing release title",
1253 wantReleasedAt: &releasedAtTime,
1254 },
1256 name: "updating with name only preserves existing notes",
1257 cli: "1.0.0 --name 'Brand New Title'",
1258 wantDescription: "Existing release description",
1259 wantName: "Brand New Title",
1260 },
1262 name: "updating with notes only preserves existing name",
1263 cli: "1.0.0 --notes 'Brand new notes'",
1264 wantDescription: "Brand new notes",
1265 wantName: "Existing release title",
1266 },
1268 name: "explicitly clearing notes with empty notes flag",
1269 cli: "1.0.0 --notes ''",
1270 wantDescription: "",
1271 wantName: "Existing release title",
1272 },
1274 name: "existing release with empty name falls back to tag name",
1275 cli: "1.0.0 --released-at '2026-10-30T10:00:00Z'",
1276 existingName: &emptyName,
1277 wantDescription: "Existing release description",
1278 wantName: "1.0.0",
1279 wantReleasedAt: &releasedAtTime,
1280 },
1283 for _, tc := range tests {
1284 t.Run(tc.name, func(t *testing.T) {
1285 tcClient := gitlabtesting.NewTestClient(t)
1286 okResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusOK}}
1288 tcClient.MockTags.EXPECT().GetTag("OWNER/REPO", "1.0.0", gomock.Any()).
1289 Return(&gitlab.Tag{Name: "1.0.0"}, nil, nil)
1291 existingName := "Existing release title"
1292 if tc.existingName != nil {
1293 existingName = *tc.existingName
1296 tcClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "1.0.0", gomock.Any()).
1297 Return(&gitlab.Release{
1298 Name: existingName,
1299 TagName: "1.0.0",
1300 Description: "Existing release description",
1301 Links: gitlab.ReleaseLinks{
1302 Self: "https://gitlab.example.com/OWNER/REPO/-/releases/1.0.0",
1303 },
1304 }, okResponse, nil)
1306 var updateCalled bool
1307 tcClient.MockReleases.EXPECT().UpdateRelease("OWNER/REPO", "1.0.0", gomock.Any()).
1308 DoAndReturn(func(pid any, tagName string, opts *gitlab.UpdateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
1309 updateCalled = true
1310 require.NotNil(t, opts.Description)
1311 assert.Equal(t, tc.wantDescription, *opts.Description)
1313 require.NotNil(t, opts.Name)
1314 assert.Equal(t, tc.wantName, *opts.Name)
1316 if tc.wantReleasedAt != nil {
1317 require.NotNil(t, opts.ReleasedAt)
1318 assert.Equal(t, *tc.wantReleasedAt, *opts.ReleasedAt)
1321 return &gitlab.Release{
1322 Name: *opts.Name,
1323 TagName: "1.0.0",
1324 Description: *opts.Description,
1325 Links: gitlab.ReleaseLinks{
1326 Self: "https://gitlab.example.com/OWNER/REPO/-/releases/1.0.0",
1327 },
1328 }, okResponse, nil
1329 })
1331 exec := cmdtest.SetupCmdForTest(
1332 t,
1333 NewCmdCreate,
1334 false,
1335 cmdtest.WithGitLabClient(tcClient.Client),
1336 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
1339 output, err := exec(tc.cli)
1340 require.NoError(t, err)
1341 assert.Contains(t, output.String(), "Release updated")
1342 require.True(t, updateCalled, "expected UpdateRelease to be called")
1343 })
1347func TestReleaseCreate_InteractiveUpdate_LeaveBlankPreservesExistingNotesAndName(t *testing.T) {
1348 testClient := gitlabtesting.NewTestClient(t)
1349 okResponse := &gitlab.Response{Response: &http.Response{StatusCode: http.StatusOK}}
1351 testClient.MockTags.EXPECT().GetTag("OWNER/REPO", "1.0.0", gomock.Any()).
1352 Return(&gitlab.Tag{Name: "1.0.0"}, nil, nil)
1354 testClient.MockReleases.EXPECT().GetRelease("OWNER/REPO", "1.0.0", gomock.Any()).
1355 Return(&gitlab.Release{
1356 Name: "Existing release title",
1357 TagName: "1.0.0",
1358 Description: "Existing release description",
1359 Links: gitlab.ReleaseLinks{
1360 Self: "https://gitlab.example.com/OWNER/REPO/-/releases/1.0.0",
1361 },
1362 }, okResponse, nil)
1364 var updateCalled bool
1365 testClient.MockReleases.EXPECT().UpdateRelease("OWNER/REPO", "1.0.0", gomock.Any()).
1366 DoAndReturn(func(pid any, tagName string, opts *gitlab.UpdateReleaseOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Release, *gitlab.Response, error) {
1367 updateCalled = true
1368 require.NotNil(t, opts.Description)
1369 assert.Equal(t, "Existing release description", *opts.Description)
1371 require.NotNil(t, opts.Name)
1372 assert.Equal(t, "Existing release title", *opts.Name)
1374 return &gitlab.Release{
1375 Name: *opts.Name,
1376 TagName: "1.0.0",
1377 Description: *opts.Description,
1378 Links: gitlab.ReleaseLinks{
1379 Self: "https://gitlab.example.com/OWNER/REPO/-/releases/1.0.0",
1380 },
1381 }, okResponse, nil
1382 })
1384 c := ugh.New(t,
1385 ugh.WithSize(cmdtest.ConsoleWidth, cmdtest.ConsoleHeight),
1386 ugh.WithTimeout(10*time.Second),
1388 c.Expect(ugh.Input("Release title (optional)")).
1389 Do(ugh.PressEnter)
1390 c.Expect(ugh.Select("Release notes")).
1391 Do(ugh.SelectOption(noteOptionsNames[noteOptLeaveBlank]))
1393 exec := cmdtest.SetupCmdForTest(
1394 t,
1395 func(f cmdutils.Factory) *cobra.Command {
1396 cmd := NewCmdCreate(f)
1397 cmdutils.EnableRepoOverride(cmd, f)
1398 ctx, cancel := context.WithTimeout(t.Context(), 15*time.Second)
1399 t.Cleanup(cancel)
1400 cmd.SetContext(ctx)
1401 return cmd
1402 },
1403 true,
1404 cmdtest.WithGitLabClient(testClient.Client),
1405 cmdtest.WithBaseRepo("OWNER", "REPO", ""),
1406 cmdtest.WithConfig(config.NewFromString("editor: vi")),
1407 cmdtest.WithConsole(t, c),
1410 output, err := exec("1.0.0 --repo OWNER/REPO")
1411 require.NoError(t, err)
1412 assert.Contains(t, output.String(), "Release updated")
1413 require.True(t, updateCalled, "expected UpdateRelease to be called")
Diagnostics8 git calls · 236 ms
CallStatusSizeTime0236 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 · 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=3
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
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=4
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 · hit4 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=1857
git.response.cache=HIT
git.response.duration_ms=4
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:0200350 B · hit2 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=350
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=b2a837e646ba305993f35203fafafb109e57a7ca
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=350
git.pkt.payload.max=323
git.sideband.band1.bytes=323
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=323
git.pack.trailer=1232131042f2ba4c9c4dbd99382667a1f0849e15
Open pack map
fetchtree:0200245 B · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=218
git.response.bytes=245
git.response.cache=HIT
git.response.duration_ms=4
git.fetch.filter=tree:0
git.fetch.wants=cb03b730c0d38e0c25330b8c3edfd648a7c3425b
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=245
git.pkt.payload.max=218
git.sideband.band1.bytes=218
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=218
git.pack.trailer=abcaa1e604d6142de985dae4beacc05f23f3a7b7
Open pack map
fetch2007.9 KiB219 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=8087
git.response.cache=MISS
git.response.duration_ms=219
git.fetch.wants=c09e7171e3e74a395e6fd516e566e18e8688009d
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=8087
git.pkt.payload.max=8060
git.sideband.band1.bytes=8060
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
a5e27b3efd3dc892
Request
f07a68ac…
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