GitLabgitlab-org

cli

main
ply6 git calls28 ms103 KiB5 cachedprotocol v2
1502 lines38 KiBRaw
1//go:build !integration
3package cmdutils
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "io"
11 "io/fs"
12 "os"
13 "path/filepath"
14 "runtime"
15 "testing"
16 "time"
18 tea "charm.land/bubbletea/v2"
19 "git.sr.ht/~timofurrer/ugh"
20 "github.com/acarl005/stripansi"
21 "github.com/stretchr/testify/assert"
22 "github.com/stretchr/testify/require"
24 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
26 "gitlab.com/gitlab-org/cli/internal/api"
27 "gitlab.com/gitlab-org/cli/internal/git"
28 "gitlab.com/gitlab-org/cli/internal/glinstance"
29 "gitlab.com/gitlab-org/cli/internal/glrepo"
30 "gitlab.com/gitlab-org/cli/internal/iostreams"
33const (
34 testConsoleWidth = 120
35 testConsoleHeight = 40
38func testIOStreamsWithConsole(t *testing.T, c *ugh.Console) (*iostreams.IOStreams, context.CancelFunc) {
39 t.Helper()
41 appInR, appInW := io.Pipe()
42 appOutR, appOutW := io.Pipe()
44 ctx, cancel := context.WithCancel(t.Context())
45 wait := c.Start(ctx, appOutR, appInW)
47 ios := iostreams.New(
48 iostreams.WithStdin(appInR, true),
49 iostreams.WithStdout(appOutW, true),
50 iostreams.WithStderr(io.Discard, true),
51 iostreams.WithProgramOptions(tea.WithWindowSize(testConsoleWidth, testConsoleHeight)),
52 )
54 cleanup := func() {
55 appInW.Close()
56 appOutW.Close()
57 appOutR.Close()
58 cancel()
59 wait()
60 }
62 return ios, cleanup
65// testIOStreams creates IOStreams for testing (avoids import cycle with cmdtest)
66func testIOStreams() *iostreams.IOStreams {
67 in := &bytes.Buffer{}
68 out := &bytes.Buffer{}
69 errOut := &bytes.Buffer{}
71 return iostreams.New(
72 iostreams.WithStdin(io.NopCloser(in), false),
73 iostreams.WithStdout(out, false),
74 iostreams.WithStderr(errOut, false),
75 )
78func Test_ParseAssignees(t *testing.T) {
79 testCases := []struct {
80 name string
81 input []string
82 wantAdd []string
83 wantRemove []string
84 wantReplace []string
85 }{
86 {
87 name: "simple replace",
88 input: []string{"foo"},
89 wantAdd: []string{},
90 wantRemove: []string{},
91 wantReplace: []string{"foo"},
92 },
93 {
94 name: "only add",
95 input: []string{"+foo"},
96 wantAdd: []string{"foo"},
97 wantRemove: []string{},
98 wantReplace: []string{},
99 },
100 {
101 name: "only remove",
102 input: []string{"-foo", "!bar"},
103 wantAdd: []string{},
104 wantRemove: []string{"foo", "bar"},
105 wantReplace: []string{},
106 },
107 {
108 name: "only replace",
109 input: []string{"baz"},
110 wantAdd: []string{},
111 wantRemove: []string{},
112 wantReplace: []string{"baz"},
113 },
114 {
115 name: "add and remove",
116 input: []string{"+qux", "-foo", "!bar"},
117 wantAdd: []string{"qux"},
118 wantRemove: []string{"foo", "bar"},
119 wantReplace: []string{},
120 },
121 {
122 name: "add and replace",
123 input: []string{"+foo", "bar"},
124 wantAdd: []string{"foo"},
125 wantRemove: []string{},
126 wantReplace: []string{"bar"},
127 },
128 {
129 name: "remove and replace",
130 input: []string{"-foo", "bar", "!baz"},
131 wantAdd: []string{},
132 wantRemove: []string{"foo", "baz"},
133 wantReplace: []string{"bar"},
134 },
135 {
136 name: "ignore empty assignee",
137 input: []string{"", "foo"},
138 wantAdd: []string{},
139 wantRemove: []string{},
140 wantReplace: []string{"foo"},
141 },
142 }
143 for _, tC := range testCases {
144 t.Run(tC.name, func(t *testing.T) {
145 uaGot := ParseAssignees(tC.input)
146 assert.ElementsMatch(t, uaGot.ToAdd, tC.wantAdd)
147 assert.ElementsMatch(t, uaGot.ToRemove, tC.wantRemove)
148 assert.ElementsMatch(t, uaGot.ToReplace, tC.wantReplace)
149 })
150 }
153func Test_VerifyAssignees(t *testing.T) {
154 testCases := []struct {
155 name string
156 input UserAssignments
157 want string // expected error message
158 }{
159 {
160 name: "empty, no errors",
161 input: UserAssignments{
162 ToAdd: []string{},
163 ToRemove: []string{},
164 ToReplace: []string{},
165 },
166 },
167 {
168 name: "simple addition, no errors",
169 input: UserAssignments{
170 ToAdd: []string{"foo"},
171 ToRemove: []string{},
172 ToReplace: []string{},
173 },
174 },
175 {
176 name: "simple removal, no errors",
177 input: UserAssignments{
178 ToAdd: []string{},
179 ToRemove: []string{"foo"},
180 ToReplace: []string{},
181 },
182 },
183 {
184 name: "simple replace, no errors",
185 input: UserAssignments{
186 ToAdd: []string{},
187 ToRemove: []string{},
188 ToReplace: []string{"foo"},
189 },
190 },
191 {
192 name: "add and removal with multiple elements, no errors",
193 input: UserAssignments{
194 ToAdd: []string{"foo", "bar", "baz"},
195 ToRemove: []string{"qux", "quux", "quz"},
196 ToReplace: []string{},
197 },
198 },
199 {
200 name: "multi replace, no errors",
201 input: UserAssignments{
202 ToAdd: []string{},
203 ToRemove: []string{},
204 ToReplace: []string{"foo", "bar"},
205 },
206 },
207 {
208 name: "replace with add, error",
209 input: UserAssignments{
210 ToAdd: []string{"bar"},
211 ToRemove: []string{},
212 ToReplace: []string{"foo"},
213 },
214 want: "mixing relative (+,!,-) and absolute assignments is forbidden",
215 },
216 {
217 name: "replace with remove, error",
218 input: UserAssignments{
219 ToAdd: []string{},
220 ToRemove: []string{"baz"},
221 ToReplace: []string{"foo"},
222 },
223 want: "mixing relative (+,!,-) and absolute assignments is forbidden",
224 },
225 {
226 name: "overlapping add and removal element, error",
227 input: UserAssignments{
228 ToAdd: []string{"foo"},
229 ToRemove: []string{"foo"},
230 ToReplace: []string{},
231 },
232 want: `1 element "foo" present in both add and remove, which is forbidden`,
233 },
234 {
235 name: "overlapping add and removal elements, error",
236 input: UserAssignments{
237 ToAdd: []string{"foo", "bar", "baz"},
238 ToRemove: []string{"foo", "baz"},
239 ToReplace: []string{},
240 },
241 want: `2 elements "foo baz" present in both add and remove, which is forbidden`,
242 },
243 }
244 for _, tC := range testCases {
245 t.Run(tC.name, func(t *testing.T) {
246 err := tC.input.VerifyAssignees()
247 if tC.want == "" {
248 if err != nil {
249 t.Errorf("VerifyAssignees() unexpected error = %s", err)
250 }
251 } else {
252 if tC.want != err.Error() {
253 t.Errorf("VerifyAssignees() expected = %s, got = %s", tC.want, err.Error())
254 }
255 }
256 })
257 }
260func Test_UsersFromReplaces(t *testing.T) {
261 testCases := []struct {
262 name string
263 users []*gitlab.User
264 expectedIDs []int64
265 expectedAction []string
266 }{
267 {
268 name: "nothingness",
269 users: []*gitlab.User{},
270 expectedIDs: []int64{},
271 expectedAction: []string{},
272 },
273 {
274 name: "single user named foo",
275 users: []*gitlab.User{
276 {ID: 1, Username: "foo"},
277 },
278 expectedIDs: []int64{1},
279 expectedAction: []string{`assigned to "@foo"`},
280 },
281 {
282 name: "multiple users named foo, bar and baz",
283 users: []*gitlab.User{
284 {ID: 1, Username: "foo"},
285 {ID: 3, Username: "bar"},
286 {ID: 7, Username: "baz"},
287 },
288 expectedIDs: []int64{1, 3, 7},
289 expectedAction: []string{`assigned to "@foo @bar @baz"`},
290 },
291 }
292 for _, tC := range testCases {
293 t.Run(tC.name, func(t *testing.T) {
294 ua := UserAssignments{}
295 api.UsersByNames = func(apiClient *gitlab.Client, names []string) ([]*gitlab.User, error) {
296 return tC.users, nil
297 }
298 var gotAction []string
299 gotIDs, gotAction, err := ua.UsersFromReplaces(&gitlab.Client{}, gotAction)
300 if err != nil {
301 t.Errorf("UsersFromReplaces() unexpected error = %s", err)
302 }
303 assert.ElementsMatch(t, *gotIDs, tC.expectedIDs)
304 assert.ElementsMatch(t, gotAction, tC.expectedAction)
305 })
306 }
309func Test_UserAssignmentsAPIFailure(t *testing.T) {
310 want := "failed to get users by their names" // Error message we want
311 ua := UserAssignments{
312 ToAdd: []string{"foo"},
313 } // Fill `ToAdd` so `cmdutils.UsersFromAddRemove()` reaches the api call
314 var err error
316 api.UsersByNames = func(apiClient *gitlab.Client, names []string) ([]*gitlab.User, error) {
317 return nil, fmt.Errorf("failed to get users by their names")
318 }
320 apiClient := gitlab.Client{} // Empty Client, it won't be used, just to satisfy the function signature
321 _, _, err = ua.UsersFromReplaces(&apiClient, nil)
322 if err == nil {
323 t.Errorf("UsersFromReplaces() expected error to not be nil")
324 }
325 if want != err.Error() {
326 t.Errorf("UsersFromReplace() expected error = %s, got = %v", want, err)
327 }
329 _, _, err = ua.UsersFromAddRemove(nil, nil, &apiClient, nil)
330 if err == nil {
331 t.Errorf("UsersFromReplaces() expected error to not be nil")
332 }
333 if want != err.Error() {
334 t.Errorf("UsersFromReplace() expected error = %s, got = %v", want, err)
335 }
338func Test_UsersFromAddRemove(t *testing.T) {
339 testCases := []struct {
340 name string
341 users []*gitlab.User // Mock *gitlab.User received from api.UsersByNames
342 merge []*gitlab.BasicUser // Mock `.Assignee field` from a merge request
343 issue []*gitlab.IssueAssignee // Mock `.Assignee field` from an issue
344 expectedIDs []int64
345 expectedAction []string
346 ua UserAssignments
347 wantErr string
348 }{
349 {
350 name: "add foo (issue and merge request)",
351 users: []*gitlab.User{
352 {
353 ID: 1,
354 Username: "foo",
355 },
356 },
357 expectedIDs: []int64{1},
358 expectedAction: []string{`assigned "@foo"`},
359 ua: UserAssignments{ToAdd: []string{"foo"}},
360 },
361 {
362 name: "add foo, bar and baz (issue and merge request)",
363 users: []*gitlab.User{
364 {
365 ID: 1,
366 Username: "foo",
367 },
368 {
369 ID: 235,
370 Username: "bar",
371 },
372 {
373 ID: 1500,
374 Username: "baz",
375 },
376 },
377 expectedIDs: []int64{1, 235, 1500},
378 expectedAction: []string{`assigned "@foo @bar @baz"`},
379 ua: UserAssignments{ToAdd: []string{"foo", "bar", "baz"}},
380 },
381 {
382 name: "remove foo (issue)",
383 users: []*gitlab.User{},
384 issue: []*gitlab.IssueAssignee{
385 {
386 ID: 1,
387 Username: "foo",
388 },
389 },
390 expectedIDs: []int64{0},
391 expectedAction: []string{`unassigned "@foo"`},
392 ua: UserAssignments{ToRemove: []string{"foo"}},
393 },
394 {
395 name: "remove foo and baz out of foo, bar and baz (issue)",
396 users: []*gitlab.User{},
397 issue: []*gitlab.IssueAssignee{
398 {
399 ID: 1,
400 Username: "foo",
401 },
402 {
403 ID: 2,
404 Username: "bar",
405 },
406 {
407 ID: 3,
408 Username: "baz",
409 },
410 },
411 expectedIDs: []int64{2},
412 expectedAction: []string{`unassigned "@foo @baz"`},
413 ua: UserAssignments{ToRemove: []string{"foo", "baz"}},
414 },
415 {
416 name: "remove foo out of foo and baz and add bar (issue)",
417 users: []*gitlab.User{
418 {
419 ID: 100,
420 Username: "bar",
421 },
422 },
423 issue: []*gitlab.IssueAssignee{
424 {
425 ID: 1,
426 Username: "foo",
427 },
428 {
429 ID: 500,
430 Username: "baz",
431 },
432 },
433 expectedIDs: []int64{500, 100},
434 expectedAction: []string{
435 `unassigned "@foo"`,
436 `assigned "@bar"`,
437 },
438 ua: UserAssignments{
439 ToAdd: []string{"bar"},
440 ToRemove: []string{"foo"},
441 },
442 },
443 {
444 name: "remove foo (merge request)",
445 users: []*gitlab.User{},
446 merge: []*gitlab.BasicUser{
447 {
448 ID: 1,
449 Username: "foo",
450 },
451 },
452 expectedIDs: []int64{0},
453 expectedAction: []string{`unassigned "@foo"`},
454 ua: UserAssignments{ToRemove: []string{"foo"}},
455 },
456 {
457 name: "remove foo and baz out of foo, bar and baz (merge request)",
458 users: []*gitlab.User{},
459 merge: []*gitlab.BasicUser{
460 {
461 ID: 1,
462 Username: "foo",
463 },
464 {
465 ID: 2,
466 Username: "bar",
467 },
468 {
469 ID: 3,
470 Username: "baz",
471 },
472 },
473 expectedIDs: []int64{2},
474 expectedAction: []string{`unassigned "@foo @baz"`},
475 ua: UserAssignments{ToRemove: []string{"foo", "baz"}},
476 },
477 {
478 name: "remove foo out of foo and baz and add bar (merge request)",
479 users: []*gitlab.User{
480 {
481 ID: 100,
482 Username: "bar",
483 },
484 },
485 merge: []*gitlab.BasicUser{
486 {
487 ID: 1,
488 Username: "foo",
489 },
490 {
491 ID: 500,
492 Username: "baz",
493 },
494 },
495 expectedIDs: []int64{500, 100},
496 expectedAction: []string{
497 `unassigned "@foo"`,
498 `assigned "@bar"`,
499 },
500 ua: UserAssignments{
501 ToAdd: []string{"bar"},
502 ToRemove: []string{"foo"},
503 },
504 },
505 {
506 name: "try to pass both issue and merge request users",
507 issue: []*gitlab.IssueAssignee{
508 {
509 ID: 1,
510 Username: "foo",
511 },
512 },
513 merge: []*gitlab.BasicUser{
514 {
515 ID: 5,
516 Username: "bar",
517 },
518 },
519 wantErr: "issueAssignees and mergeRequestAssignees can't both be set",
520 },
521 }
522 for _, tC := range testCases {
523 t.Run(tC.name, func(t *testing.T) {
524 api.UsersByNames = func(_ *gitlab.Client, _ []string) ([]*gitlab.User, error) {
525 return tC.users, nil
526 }
527 var gotAction []string
528 gotIDs, gotAction, err := tC.ua.UsersFromAddRemove(tC.issue, tC.merge, &gitlab.Client{}, gotAction)
529 if err != nil {
530 if tC.wantErr != "" && tC.wantErr != err.Error() {
531 t.Errorf("UsersFromAddRemove() expected error = %s, got = %s", tC.wantErr, err)
532 } else if tC.wantErr == "" {
533 t.Errorf("UsersFromAddRemove() unexpected error = %s", err)
534 }
535 }
537 assert.ElementsMatch(t, *gotIDs, tC.expectedIDs)
538 assert.ElementsMatch(t, gotAction, tC.expectedAction)
539 })
540 }
543func Test_ParseMilestoneTitleIsID(t *testing.T) {
544 title := "1"
545 expectedMilestoneID := int64(1)
547 // Override function to return an error, it should never reach this
548 projectMilestoneByTitle = func(client *gitlab.Client, projectID any, name string) (*gitlab.Milestone, error) {
549 return nil, fmt.Errorf("We shouldn't have reached here")
550 }
552 got, err := ParseMilestone(&gitlab.Client{}, glrepo.New("foo", "bar", glinstance.DefaultHostname), title)
553 if err != nil {
554 t.Errorf("ParseMilestone() unexpected error = %s", err)
555 }
556 if got != expectedMilestoneID {
557 t.Errorf("ParseMilestone() got = %d, expected = %d", got, expectedMilestoneID)
558 }
561func Test_ParseMilestoneAPIFail(t *testing.T) {
562 title := "AsLongAsItDoesn'tConvertToInt"
563 want := "API call failed in api.MilestoneByTitle()."
565 // Override function to return an error simulating an API call failure
566 projectMilestoneByTitle = func(client *gitlab.Client, projectID any, name string) (*gitlab.Milestone, error) {
567 return nil, fmt.Errorf("API call failed in api.MilestoneByTitle().")
568 }
570 _, err := ParseMilestone(&gitlab.Client{}, glrepo.New("foo", "bar", glinstance.DefaultHostname), title)
571 if err == nil {
572 t.Errorf("ParseMilestone() expected error")
573 }
574 if want != err.Error() {
575 t.Errorf("ParseMilestone() expected error = %s, got error = %s", want, err)
576 }
579func Test_ParseMilestoneTitleToID(t *testing.T) {
580 milestoneTitle := "kind: testing"
581 expectedID := int64(3)
583 // Override function so it returns the correct milestone
584 projectMilestoneByTitle = func(_ *gitlab.Client, _ any, _ string) (*gitlab.Milestone, error) {
585 return &gitlab.Milestone{
586 Title: "kind: testing",
587 ID: 3,
588 },
589 nil
590 }
592 got, err := ParseMilestone(&gitlab.Client{}, glrepo.New("foo", "bar", glinstance.DefaultHostname), milestoneTitle)
593 if err != nil {
594 t.Errorf("ParseMilestone() unexpected error = %s", err)
595 }
596 if got != expectedID {
597 t.Errorf("ParseMilestone() expected = %d, got = %d", expectedID, got)
598 }
601func Test_PickMetadata(t *testing.T) {
602 t.Parallel()
604 testCases := []struct {
605 name string
606 values []int
607 expected []Action
608 skipReason string
609 }{
610 {
611 name: "nothing picked",
612 skipReason: "empty multi-select not yet supported",
613 },
614 {
615 name: "labels",
616 values: []int{0}, // Select first option: "labels"
617 expected: []Action{AddLabelAction},
618 },
619 {
620 name: "assignees",
621 values: []int{1}, // Select second option: "assignees"
622 expected: []Action{AddAssigneeAction},
623 },
624 {
625 name: "milestone",
626 values: []int{2}, // Select third option: "milestones"
627 expected: []Action{AddMilestoneAction},
628 },
629 {
630 name: "labels and assignees",
631 values: []int{0, 1},
632 expected: []Action{AddLabelAction, AddAssigneeAction},
633 },
634 {
635 name: "labels and milestone",
636 values: []int{0, 2},
637 expected: []Action{AddLabelAction, AddMilestoneAction},
638 },
639 {
640 name: "assignees and milestone",
641 values: []int{1, 2},
642 expected: []Action{AddAssigneeAction, AddMilestoneAction},
643 },
644 {
645 name: "labels, assignees and milestone",
646 values: []int{0, 1, 2},
647 expected: []Action{AddLabelAction, AddAssigneeAction, AddMilestoneAction},
648 },
649 }
650 for _, tC := range testCases {
651 t.Run(tC.name, func(t *testing.T) {
652 t.Parallel()
654 if tC.skipReason != "" {
655 t.Skip(tC.skipReason)
656 }
658 c := ugh.New(t)
659 c.Expect(ugh.MultiSelect("Which metadata types to add?")).
660 Do(ugh.ToggleIndices(tC.values...))
662 ios, cancel := testIOStreamsWithConsole(t, c)
663 defer cancel()
665 got, err := PickMetadata(t.Context(), ios)
666 if err != nil {
667 t.Errorf("PickMetadata() unexpected error = %s", err)
668 }
669 assert.ElementsMatch(t, got, tC.expected)
670 })
671 }
673 t.Run("Prompt fails", func(t *testing.T) {
674 // For testing prompt failure, we can use a responder that doesn't provide a response
675 // This will cause a timeout/error
676 c := ugh.New(t, ugh.WithSize(testConsoleWidth, testConsoleHeight), ugh.WithTimeout(100*time.Millisecond))
677 // No expects - will timeout
679 ios, cancel := testIOStreamsWithConsole(t, c)
680 defer cancel()
682 // Use a short context timeout to make the test fail quickly
683 ctx, ctxCancel := context.WithTimeout(t.Context(), 100*time.Millisecond)
684 defer ctxCancel()
686 got, err := PickMetadata(ctx, ios)
687 assert.Nil(t, got)
688 require.Error(t, err)
689 assert.Contains(t, err.Error(), "could not prompt")
690 })
693func Test_UsersPrompt(t *testing.T) {
694 // mock glrepo.Remote object
695 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
696 remote := &git.Remote{
697 Name: "test",
698 Resolved: "base",
699 }
700 repoRemote := &glrepo.Remote{
701 Remote: remote,
702 Repo: repo,
703 }
705 testCases := []struct {
706 name string
707 choiceIndices []int
708 mock []*gitlab.ProjectMember
709 output []string
710 minimumAccessLevel int
711 expectedStdErr string
712 expectedError string
713 skipReason string
714 }{
715 {
716 name: "nothing",
717 skipReason: "empty multi-select not yet supported",
718 },
719 {
720 name: "reporter",
721 choiceIndices: []int{0},
722 output: []string{"foo"},
723 minimumAccessLevel: 20,
724 mock: []*gitlab.ProjectMember{
725 {
726 Username: "foo",
727 AccessLevel: gitlab.AccessLevelValue(20),
728 },
729 },
730 },
731 {
732 name: "reporter-developer",
733 choiceIndices: []int{0, 1},
734 output: []string{"foo", "bar"},
735 minimumAccessLevel: 20,
736 mock: []*gitlab.ProjectMember{
737 {
738 Username: "foo",
739 AccessLevel: gitlab.AccessLevelValue(20),
740 },
741 {
742 Username: "bar",
743 AccessLevel: gitlab.AccessLevelValue(30),
744 },
745 },
746 },
747 {
748 name: "reporter-developer-maintainer",
749 choiceIndices: []int{0, 1, 2},
750 output: []string{"foo", "bar", "baz"},
751 minimumAccessLevel: 20,
752 mock: []*gitlab.ProjectMember{
753 {
754 Username: "foo",
755 AccessLevel: gitlab.AccessLevelValue(20),
756 },
757 {
758 Username: "bar",
759 AccessLevel: gitlab.AccessLevelValue(30),
760 },
761 {
762 Username: "baz",
763 AccessLevel: gitlab.AccessLevelValue(40),
764 },
765 },
766 },
767 {
768 name: "no-members",
769 minimumAccessLevel: 10,
770 mock: []*gitlab.ProjectMember{},
771 expectedStdErr: "Couldn't fetch any members with minimum permission level 10.\n",
772 },
773 {
774 name: "no-valid-members",
775 minimumAccessLevel: 50,
776 mock: []*gitlab.ProjectMember{
777 {
778 Username: "foo",
779 AccessLevel: gitlab.AccessLevelValue(40),
780 },
781 },
782 expectedStdErr: "Couldn't fetch any members with minimum permission level 50.\n",
783 },
784 }
785 for _, tC := range testCases {
786 t.Run(tC.name, func(t *testing.T) {
787 if tC.skipReason != "" {
788 t.Skip(tC.skipReason)
789 }
791 listProjectMembers = func(ctx context.Context, client *gitlab.Client, projectID any, opts *gitlab.ListProjectMembersOptions) ([]*gitlab.ProjectMember, error) {
792 return tC.mock, nil
793 }
795 var got []string
796 var io *iostreams.IOStreams
797 var cancel context.CancelFunc
799 // Cases with no members don't need responder (return early)
800 if tC.name == "no-members" || tC.name == "no-valid-members" {
801 stderr := &bytes.Buffer{}
802 io = iostreams.New(iostreams.WithStderr(stderr, false))
804 err := UsersPrompt(t.Context(), &got, &gitlab.Client{}, repoRemote, io, tC.minimumAccessLevel, "some users")
805 if tC.expectedError != "" {
806 require.EqualError(t, err, tC.expectedError)
807 } else {
808 require.NoError(t, err)
809 }
810 if tC.expectedStdErr != "" {
811 outErr := stripansi.Strip(stderr.String())
812 assert.Equal(t, tC.expectedStdErr, outErr)
813 }
814 assert.ElementsMatch(t, got, tC.output)
815 return
816 }
818 c := ugh.New(t)
819 c.Expect(ugh.MultiSelect("Select some users")).
820 Do(ugh.ToggleIndices(tC.choiceIndices...))
821 io, cancel = testIOStreamsWithConsole(t, c)
822 defer cancel()
824 ctx, ctxCancel := context.WithTimeout(t.Context(), 2*time.Second)
825 defer ctxCancel()
827 err := UsersPrompt(ctx, &got, &gitlab.Client{}, repoRemote, io, tC.minimumAccessLevel, "some users")
828 if tC.expectedError != "" {
829 require.EqualError(t, err, tC.expectedError)
830 } else {
831 require.NoError(t, err)
832 }
833 if tC.expectedStdErr != "" {
834 stderrBuf, ok := io.StdErr.(*bytes.Buffer)
835 require.True(t, ok, "test setup wires StdErr to a *bytes.Buffer")
836 outErr := stripansi.Strip(stderrBuf.String())
837 assert.Equal(t, tC.expectedStdErr, outErr)
838 }
839 assert.ElementsMatch(t, got, tC.output)
840 })
841 }
843 t.Run("Prompt fails", func(t *testing.T) {
844 t.Skip("prompt failure simulation not yet supported")
845 })
847 t.Run("API Failed", func(t *testing.T) {
848 var got []string
850 listProjectMembers = func(ctx context.Context, client *gitlab.Client, projectID any, opts *gitlab.ListProjectMembersOptions) ([]*gitlab.ProjectMember, error) {
851 return nil, errors.New("meant to fail")
852 }
854 err := UsersPrompt(t.Context(), &got, &gitlab.Client{}, repoRemote, nil, 20, "assignees")
855 assert.Empty(t, got)
856 assert.EqualError(t, err, "meant to fail")
857 })
859 t.Run("respect-flags", func(t *testing.T) {
860 got := []string{"foo"}
862 listProjectMembers = func(_ context.Context, _ *gitlab.Client, _ any, _ *gitlab.ListProjectMembersOptions) ([]*gitlab.ProjectMember, error) {
863 return []*gitlab.ProjectMember{
864 {
865 Username: "foo",
866 AccessLevel: gitlab.AccessLevelValue(20),
867 },
868 {
869 Username: "bar",
870 AccessLevel: gitlab.AccessLevelValue(30),
871 },
872 }, nil
873 }
875 c := ugh.New(t)
876 c.Expect(ugh.MultiSelect("Select assignees")).
877 Do(ugh.ToggleIndices(1))
878 io, cancel := testIOStreamsWithConsole(t, c)
879 defer cancel()
881 ctx, ctxCancel := context.WithTimeout(t.Context(), 2*time.Second)
882 defer ctxCancel()
884 err := UsersPrompt(ctx, &got, &gitlab.Client{}, repoRemote, io, 20, "assignees")
885 require.NoError(t, err)
886 assert.ElementsMatch(t, []string{"foo", "bar"}, got)
887 })
890func Test_MilestonesPrompt(t *testing.T) {
891 mockMilestones := []*api.Milestone{
892 {
893 Title: "New Release",
894 ID: 5,
895 },
896 {
897 Title: "Really big feature",
898 ID: 240,
899 },
900 {
901 Title: "Get rid of low quality Code",
902 ID: 650,
903 },
904 }
906 // Override API.ListMilestones so it doesn't make any network calls
907 api.ListAllMilestones = func(_ *gitlab.Client, _ any, _ *api.ListMilestonesOptions) ([]*api.Milestone, error) {
908 return mockMilestones, nil
909 }
911 // mock glrepo.Remote object
912 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
913 remote := &git.Remote{
914 Name: "test",
915 Resolved: "base",
916 }
917 repoRemote := &glrepo.Remote{
918 Remote: remote,
919 Repo: repo,
920 }
922 testCases := []struct {
923 name string
924 inputIdx int // Selected milestone
925 expectedID int64 // expected global ID from the milestone
926 }{
927 {
928 name: "match",
929 inputIdx: 0,
930 expectedID: 5,
931 },
932 }
933 for _, tC := range testCases {
934 t.Run(tC.name, func(t *testing.T) {
935 c := ugh.New(t)
936 c.Expect(ugh.Select("Select milestone")).
937 Do(ugh.SelectIndex(tC.inputIdx))
938 ios, cleanup := testIOStreamsWithConsole(t, c)
939 t.Cleanup(cleanup)
941 var got int64
942 err := MilestonesPrompt(t.Context(), &got, &gitlab.Client{}, repoRemote, ios)
943 if err != nil {
944 t.Errorf("MilestonesPrompt() unexpected error = %s", err)
945 }
946 if got != 0 && got != tC.expectedID {
947 t.Errorf("MilestonesPrompt() expected = %d, got = %d", got, tC.expectedID)
948 }
949 })
950 }
953func Test_MilestonesPromptNoPrompts(t *testing.T) {
954 // Override api.ListMilestones so it returns an empty slice, we are testing if MilestonesPrompt()
955 // will print the correct message to `stderr` when it tries to get the list of Milestones in a
956 // project but the project has no milestones
957 api.ListAllMilestones = func(_ *gitlab.Client, _ any, _ *api.ListMilestonesOptions) ([]*api.Milestone, error) {
958 return []*api.Milestone{}, nil
959 }
961 // mock glrepo.Remote object
962 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
963 remote := &git.Remote{
964 Name: "test",
965 Resolved: "base",
966 }
967 repoRemote := &glrepo.Remote{
968 Remote: remote,
969 Repo: repo,
970 }
972 var got int64
973 stderr := &bytes.Buffer{}
974 io := iostreams.New(iostreams.WithStderr(stderr, false))
976 err := MilestonesPrompt(t.Context(), &got, &gitlab.Client{}, repoRemote, io)
977 if err != nil {
978 t.Errorf("MilestonesPrompt() unexpected error = %s", err)
979 }
980 assert.Equal(t, "No active milestones exist for this project.\n", stderr.String())
983func TestMilestonesPromptFailures(t *testing.T) {
984 // Override api.ListMilestones so it returns an error, we are testing to see if error
985 // handling from the usage of api.ListMilestones is correct
986 api.ListAllMilestones = func(_ *gitlab.Client, _ any, _ *api.ListMilestonesOptions) ([]*api.Milestone, error) {
987 return nil, errors.New("api.ListMilestones() failed")
988 }
990 // mock glrepo.Remote object
991 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
992 remote := &git.Remote{
993 Name: "test",
994 Resolved: "base",
995 }
996 repoRemote := &glrepo.Remote{
997 Remote: remote,
998 Repo: repo,
999 }
1001 var got int64
1002 io := iostreams.New()
1004 err := MilestonesPrompt(t.Context(), &got, &gitlab.Client{}, repoRemote, io)
1005 if err == nil {
1006 t.Error("MilestonesPrompt() expected error")
1008 assert.Equal(t, "api.ListMilestones() failed", err.Error())
1011func Test_IDsFromUsers(t *testing.T) {
1012 testCases := []struct {
1013 name string
1014 users []*gitlab.User // Mock of the gitlab.User object
1015 IDs []int64 // IDs we expect from the users
1016 }{
1018 name: "no users",
1019 },
1021 name: "one user",
1022 users: []*gitlab.User{
1024 ID: 1,
1025 },
1026 },
1027 IDs: []int64{1},
1028 },
1030 name: "multiple users",
1031 users: []*gitlab.User{
1033 ID: 3,
1034 },
1036 ID: 6,
1037 },
1039 ID: 2,
1040 },
1042 ID: 51,
1043 },
1045 ID: 32,
1046 },
1048 ID: 87,
1049 },
1051 ID: 210,
1052 },
1054 ID: 6493,
1055 },
1057 ID: 50132,
1058 },
1059 },
1060 IDs: []int64{
1061 50132,
1062 6493,
1063 210,
1064 87,
1065 32,
1066 51,
1067 2,
1068 3,
1069 6,
1070 },
1071 },
1073 for _, tC := range testCases {
1074 t.Run(tC.name, func(t *testing.T) {
1075 got := IDsFromUsers(tC.users)
1076 assert.ElementsMatch(t, *got, tC.IDs)
1077 })
1081func Test_LabelsPromptAPIFail(t *testing.T) {
1082 // mock glrepo.Remote object
1083 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
1084 remote := &git.Remote{
1085 Name: "test",
1086 Resolved: "base",
1088 repoRemote := &glrepo.Remote{
1089 Remote: remote,
1090 Repo: repo,
1093 listLabels = func(_ *gitlab.Client, _ any, _ *gitlab.ListLabelsOptions) ([]*gitlab.Label, error) {
1094 return nil, errors.New("API call failed")
1097 var got []string
1098 ios := testIOStreams()
1099 err := LabelsPrompt(t.Context(), ios, &got, &gitlab.Client{}, repoRemote)
1100 assert.Nil(t, got)
1101 assert.EqualError(t, err, "API call failed")
1104func Test_LabelsPromptPromptsFail(t *testing.T) {
1105 t.Run("MultiSelect", func(t *testing.T) {
1106 t.Skip("prompt failure simulation not yet supported")
1107 })
1109 t.Run("AskQuestionWithInput", func(t *testing.T) {
1110 t.Skip("prompt failure simulation not yet supported")
1111 })
1114func Test_LabelsPromptMultiSelect(t *testing.T) {
1115 // mock glrepo.Remote object
1116 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
1117 remote := &git.Remote{
1118 Name: "test",
1119 Resolved: "base",
1121 repoRemote := &glrepo.Remote{
1122 Remote: remote,
1123 Repo: repo,
1126 listLabels = func(_ *gitlab.Client, _ any, _ *gitlab.ListLabelsOptions) ([]*gitlab.Label, error) {
1127 return []*gitlab.Label{
1129 Name: "foo",
1130 },
1132 Name: "bar",
1133 },
1135 Name: "baz",
1136 },
1138 Name: "qux",
1139 },
1141 Name: "quux",
1142 },
1144 Name: "quz",
1145 },
1146 }, nil
1149 testCases := []struct {
1150 name string
1151 choiceIndices []int
1152 labels []string // Can be set to have initial labels
1153 expected []string // expected labels
1154 skipReason string
1155 }{
1157 name: "simple",
1158 choiceIndices: []int{0, 1}, // Select "foo" and "bar"
1159 expected: []string{"foo", "bar"},
1160 },
1162 name: "respect-defined-labels",
1163 choiceIndices: []int{0}, // Select "foo"
1164 labels: []string{"bar"},
1165 expected: []string{"foo", "bar"},
1166 },
1168 name: "nothing",
1169 skipReason: "empty multi-select not yet supported",
1170 },
1172 name: "nothing-but-respect-already-defined",
1173 labels: []string{"qux"},
1174 expected: []string{"qux"},
1175 skipReason: "empty multi-select not yet supported",
1176 },
1178 for _, tC := range testCases {
1179 t.Run(tC.name, func(t *testing.T) {
1180 if tC.skipReason != "" {
1181 t.Skip(tC.skipReason)
1184 c := ugh.New(t)
1185 c.Expect(ugh.MultiSelect("Select labels")).
1186 Do(ugh.ToggleIndices(tC.choiceIndices...))
1187 ios, cancel := testIOStreamsWithConsole(t, c)
1188 defer cancel()
1190 ctx, ctxCancel := context.WithTimeout(t.Context(), 2*time.Second)
1191 defer ctxCancel()
1193 err := LabelsPrompt(ctx, ios, &tC.labels, &gitlab.Client{}, repoRemote)
1194 require.NoError(t, err)
1195 assert.ElementsMatch(t, tC.labels, tC.expected)
1196 })
1200func Test_LabelsPromptAskQuestionWithInput(t *testing.T) {
1201 // mock glrepo.Remote object
1202 repo := glrepo.New("foo", "bar", glinstance.DefaultHostname)
1203 remote := &git.Remote{
1204 Name: "test",
1205 Resolved: "base",
1207 repoRemote := &glrepo.Remote{
1208 Remote: remote,
1209 Repo: repo,
1212 listLabels = func(_ *gitlab.Client, _ any, _ *gitlab.ListLabelsOptions) ([]*gitlab.Label, error) {
1213 return []*gitlab.Label{}, nil
1216 testCases := []struct {
1217 name string
1218 input string
1219 labels []string // Can be set to have initial labels
1220 expected []string // expected labels
1221 }{
1223 name: "simple",
1224 input: "foo,bar",
1225 expected: []string{"foo", "bar"},
1226 },
1228 name: "respect-defined-labels",
1229 input: "foo",
1230 labels: []string{"bar"},
1231 expected: []string{"foo", "bar"},
1232 },
1234 name: "nothing",
1235 },
1237 name: "nothing-but-respect-already-defined",
1238 labels: []string{"qux"},
1239 expected: []string{"qux"},
1240 },
1242 for _, tC := range testCases {
1243 t.Run(tC.name, func(t *testing.T) {
1244 c := ugh.New(t)
1245 c.Expect(ugh.Input("Label(s) (comma-separated)")).
1246 Do(ugh.Type(tC.input))
1247 ios, cancel := testIOStreamsWithConsole(t, c)
1248 defer cancel()
1250 ctx, ctxCancel := context.WithTimeout(t.Context(), 2*time.Second)
1251 defer ctxCancel()
1253 err := LabelsPrompt(ctx, ios, &tC.labels, &gitlab.Client{}, repoRemote)
1254 require.NoError(t, err)
1255 assert.ElementsMatch(t, tC.labels, tC.expected)
1256 })
1260func Test_ConfirmSubmission(t *testing.T) {
1261 const (
1262 submitLabelIdx = 0
1263 previewLabelIdx = 1
1264 addMetadataLabelIdx = 2
1265 cancelLabelIdx = 3
1268 t.Run("success", func(t *testing.T) {
1269 testCases := []struct {
1270 name string
1271 optionIdx int
1272 allowAddMetadata bool
1273 output Action
1274 }{
1276 name: "submit",
1277 optionIdx: submitLabelIdx,
1278 output: SubmitAction,
1279 },
1281 name: "preview",
1282 optionIdx: previewLabelIdx,
1283 output: PreviewAction,
1284 },
1286 name: "Add Metadata",
1287 optionIdx: addMetadataLabelIdx,
1288 allowAddMetadata: true,
1289 output: AddMetadataAction,
1290 },
1292 name: "cancel",
1293 optionIdx: cancelLabelIdx - 1, // no metadata
1294 output: CancelAction,
1295 },
1297 for _, tC := range testCases {
1298 t.Run(tC.name, func(t *testing.T) {
1299 c := ugh.New(t)
1300 c.Expect(ugh.Select("What's next?")).
1301 Do(ugh.SelectIndex(tC.optionIdx))
1302 ios, cleanup := testIOStreamsWithConsole(t, c)
1303 t.Cleanup(cleanup)
1305 got, err := ConfirmSubmission(t.Context(), ios, tC.allowAddMetadata)
1306 require.NoError(t, err)
1307 assert.Equal(t, tC.output, got)
1308 })
1310 })
1313func TestListGitLabTemplates(t *testing.T) {
1314 originalToplevelDir := git.ToplevelDir
1315 t.Cleanup(func() { git.ToplevelDir = originalToplevelDir })
1316 tests := []struct {
1317 name string
1318 give string
1319 wantTemplates []string
1320 wantErr bool
1321 }{
1323 name: "Get all the issues templates",
1324 give: "issue_templates",
1325 wantTemplates: []string{"Bug", "Feature Request"},
1326 },
1328 name: "Get all the merge request templates",
1329 give: "merge_request_templates",
1330 wantTemplates: []string{"Default"},
1331 },
1334 for _, test := range tests {
1335 t.Run(test.name, func(t *testing.T) {
1336 git.ToplevelDir = func() (string, error) { return "../../test/testdata", nil }
1337 gotTemplates, gotErr := ListGitLabTemplates(test.give)
1338 require.Equal(t, test.wantErr, (gotErr != nil))
1339 assert.Equal(t, test.wantTemplates, gotTemplates, "Templates got didn't match")
1340 })
1344func TestListGitLabTemplatesFilesystemErrors(t *testing.T) {
1345 originalToplevelDir := git.ToplevelDir
1346 t.Cleanup(func() { git.ToplevelDir = originalToplevelDir })
1348 for _, tc := range []struct {
1349 name string
1350 outsideRepo bool
1351 folderIsFile bool
1352 permissionDenied bool
1353 }{
1354 {name: "missing directory"},
1355 {name: "outside repository", outsideRepo: true},
1356 {name: "template directory is a file", folderIsFile: true},
1357 {name: "unreadable directory", permissionDenied: true},
1358 } {
1359 t.Run(tc.name, func(t *testing.T) {
1360 root := t.TempDir()
1361 git.ToplevelDir = func() (string, error) {
1362 if tc.outsideRepo {
1363 return "", git.ErrNotAGitRepository
1365 return root, nil
1367 folder := filepath.Join(root, ".gitlab", IssueTemplate)
1368 if tc.permissionDenied {
1369 if runtime.GOOS == "windows" {
1370 t.Skip("directory mode permissions are not enforced on Windows")
1372 require.NoError(t, os.MkdirAll(folder, 0o755))
1373 require.NoError(t, os.Chmod(folder, 0))
1374 t.Cleanup(func() { require.NoError(t, os.Chmod(folder, 0o755)) })
1375 if _, err := os.ReadDir(folder); err == nil {
1376 t.Skip("current user can read mode-000 directories")
1379 if tc.folderIsFile {
1380 require.NoError(t, os.MkdirAll(filepath.Dir(folder), 0o755))
1381 require.NoError(t, os.WriteFile(folder, []byte("not a directory"), 0o644))
1383 templates, err := ListGitLabTemplates(IssueTemplate)
1384 assert.Empty(t, templates)
1385 if tc.folderIsFile || tc.permissionDenied {
1386 var pathErr *os.PathError
1387 require.ErrorAs(t, err, &pathErr)
1388 assert.Equal(t, folder, pathErr.Path)
1389 if tc.permissionDenied {
1390 require.ErrorIs(t, err, os.ErrPermission)
1392 } else {
1393 require.NoError(t, err)
1395 })
1399func TestLoadGitLabTemplate(t *testing.T) {
1400 // Cannot use t.Parallel(): subtests mutate git.ToplevelDir, a package-level variable.
1401 origToplevelDir := git.ToplevelDir
1402 t.Cleanup(func() { git.ToplevelDir = origToplevelDir })
1404 repoDir := t.TempDir()
1405 repoTemplateDir := filepath.Join(repoDir, ".gitlab", IssueTemplate)
1406 require.NoError(t, os.MkdirAll(repoTemplateDir, 0o755))
1407 require.NoError(t, os.WriteFile(filepath.Join(repoTemplateDir, "bug.md"), []byte("\nrepo template\n"), 0o644))
1409 outsideDir := t.TempDir()
1410 outsideFile := filepath.Join(outsideDir, "team", "bug.md")
1411 require.NoError(t, os.MkdirAll(filepath.Dir(outsideFile), 0o755))
1412 require.NoError(t, os.WriteFile(outsideFile, []byte("\noutside template\n"), 0o644))
1414 inRepo := func() { git.ToplevelDir = func() (string, error) { return repoDir, nil } }
1415 outsideRepo := func() {
1416 git.ToplevelDir = func() (string, error) { return "", errors.New("not a git repository") }
1419 t.Run("bare name resolves in repository", func(t *testing.T) {
1420 inRepo()
1422 got, err := LoadGitLabTemplate(IssueTemplate, "bug")
1423 require.NoError(t, err)
1424 assert.Equal(t, "repo template", got)
1425 })
1427 t.Run("bare name with extension resolves in repository", func(t *testing.T) {
1428 inRepo()
1430 got, err := LoadGitLabTemplate(IssueTemplate, "bug.md")
1431 require.NoError(t, err)
1432 assert.Equal(t, "repo template", got)
1433 })
1435 t.Run("missing bare name returns empty string", func(t *testing.T) {
1436 inRepo()
1438 got, err := LoadGitLabTemplate(IssueTemplate, "nonexistent")
1439 require.NoError(t, err)
1440 assert.Empty(t, got)
1441 })
1443 t.Run("bare name outside repository returns error", func(t *testing.T) {
1444 outsideRepo()
1446 _, err := LoadGitLabTemplate(IssueTemplate, "bug")
1447 assert.ErrorContains(t, err, "not a git repository")
1448 })
1450 t.Run("absolute path outside repository", func(t *testing.T) {
1451 outsideRepo()
1453 got, err := LoadGitLabTemplate(IssueTemplate, outsideFile)
1454 require.NoError(t, err)
1455 assert.Equal(t, "outside template", got)
1456 })
1458 t.Run("relative path with separator", func(t *testing.T) {
1459 inRepo()
1460 t.Chdir(outsideDir)
1462 got, err := LoadGitLabTemplate(IssueTemplate, "team/bug.md")
1463 require.NoError(t, err)
1464 assert.Equal(t, "outside template", got)
1465 })
1467 t.Run("home directory path", func(t *testing.T) {
1468 outsideRepo()
1469 t.Setenv("HOME", outsideDir)
1470 t.Setenv("USERPROFILE", outsideDir)
1472 got, err := LoadGitLabTemplate(IssueTemplate, "~/team/bug.md")
1473 require.NoError(t, err)
1474 assert.Equal(t, "outside template", got)
1475 })
1477 t.Run("path is read verbatim without appending extension", func(t *testing.T) {
1478 outsideRepo()
1480 _, err := LoadGitLabTemplate(IssueTemplate, filepath.Join(outsideDir, "team", "bug"))
1481 assert.ErrorIs(t, err, fs.ErrNotExist)
1482 })
1484 t.Run("missing path returns error", func(t *testing.T) {
1485 inRepo()
1487 _, err := LoadGitLabTemplate(IssueTemplate, filepath.Join(outsideDir, "missing.md"))
1488 assert.ErrorIs(t, err, fs.ErrNotExist)
1489 })
1491 t.Run("empty or whitespace-only path returns error", func(t *testing.T) {
1492 inRepo()
1494 for name, content := range map[string]string{"empty": "", "whitespace": " \n\t\n"} {
1495 file := filepath.Join(outsideDir, name+".md")
1496 require.NoError(t, os.WriteFile(file, []byte(content), 0o644))
1498 _, err := LoadGitLabTemplate(IssueTemplate, file)
1499 assert.ErrorContains(t, err, "is empty")
1501 })
Diagnostics6 git calls · 28 ms
CallStatusSizeTime028 ms
discover200185 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=2
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchtree:02001.2 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=1238
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=c10f4b8b760c3fec7ed8ca85e428d5bc523f8e17
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=1238
git.pkt.payload.max=1211
git.sideband.band1.bytes=1211
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1211
git.pack.trailer=7373aa350f2a611db7d4116eb1450c92f18a27ca
Open pack map
fetch2007.1 KiB · hit21 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=20
git.response.bytes=7271
git.response.cache=HIT
git.response.duration_ms=21
git.fetch.wants=cc7d652689fb0326a728a02fdb4eaf0a6141ccab
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=7271
git.pkt.payload.max=7244
git.sideband.band1.bytes=7244
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
a5e125f928c97fd8
Request
32acfad9…
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