GitLabgitlab-org

cli

main
ply8 git calls307 ms100 KiB6 cachedprotocol v2
730 lines22 KiBRaw
1//go:build !integration
3package list
5import (
6 "testing"
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10 "go.uber.org/mock/gomock"
12 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
13 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
15 workitemsapi "gitlab.com/gitlab-org/cli/internal/commands/workitems/api"
16 "gitlab.com/gitlab-org/cli/internal/glinstance"
17 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
20func TestWorkItemsList(t *testing.T) {
21 tests := []struct {
22 name string
23 args string
24 setupMock func(tc *gitlabtesting.TestClient)
25 wantErr bool
26 wantOutput string
27 }{
28 {
29 name: "lists work items in project",
30 args: "",
31 setupMock: func(tc *gitlabtesting.TestClient) {
32 tc.MockGraphQL.EXPECT().
33 Do(gomock.Any(), gomock.Any(), gomock.Any()).
34 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
35 // Type assert to the exact structure used in api.go
36 resp, _ := response.(*workitemsapi.WorkItemsResponse)
38 // Populate mock response with project work items
39 resp.Data.Project = &workitemsapi.ProjectWorkItems{
40 WorkItems: workitemsapi.WorkItemsConnection{
41 Nodes: []workitemsapi.WorkItem{
42 {
43 IID: "1",
44 Title: "Implement new feature",
45 State: "OPEN",
46 WorkItemType: struct {
47 Name string `json:"name"`
48 }{
49 Name: "Issue",
50 },
51 Author: struct {
52 Username string `json:"username"`
53 }{
54 Username: "testuser",
55 },
56 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/1",
57 },
58 {
59 IID: "2",
60 Title: "Fix critical bug",
61 State: "CLOSED",
62 WorkItemType: struct {
63 Name string `json:"name"`
64 }{
65 Name: "Issue",
66 },
67 Author: struct {
68 Username string `json:"username"`
69 }{
70 Username: "anotheruser",
71 },
72 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/2",
73 },
74 },
75 PageInfo: workitemsapi.PageInfo{
76 EndCursor: "",
77 HasNextPage: false,
78 },
79 },
80 }
82 return &gitlab.Response{}, nil
83 })
84 },
85 wantOutput: "Implement new feature",
86 },
87 {
88 name: "lists work items in group",
89 args: "--group test-group",
90 setupMock: func(tc *gitlabtesting.TestClient) {
91 tc.MockGraphQL.EXPECT().
92 Do(gomock.Any(), gomock.Any(), gomock.Any()).
93 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
94 resp, _ := response.(*workitemsapi.WorkItemsResponse)
96 // Populate mock response with group work items
97 resp.Data.Group = &workitemsapi.GroupWorkItems{
98 WorkItems: workitemsapi.WorkItemsConnection{
99 Nodes: []workitemsapi.WorkItem{
100 {
101 IID: "1",
102 Title: "Epic for Q1",
103 State: "OPEN",
104 WorkItemType: struct {
105 Name string `json:"name"`
106 }{
107 Name: "Epic",
108 },
109 Author: struct {
110 Username string `json:"username"`
111 }{
112 Username: "groupowner",
113 },
114 WebURL: "https://gitlab.com/groups/test-group/-/epics/1",
115 },
116 },
117 PageInfo: workitemsapi.PageInfo{
118 EndCursor: "",
119 HasNextPage: false,
120 },
121 },
122 }
124 return &gitlab.Response{}, nil
125 })
126 },
127 wantOutput: "Epic for Q1",
128 },
129 {
130 name: "empty work items list",
131 args: "",
132 setupMock: func(tc *gitlabtesting.TestClient) {
133 tc.MockGraphQL.EXPECT().
134 Do(gomock.Any(), gomock.Any(), gomock.Any()).
135 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
136 resp, _ := response.(*workitemsapi.WorkItemsResponse)
138 resp.Data.Project = &workitemsapi.ProjectWorkItems{
139 WorkItems: workitemsapi.WorkItemsConnection{
140 Nodes: []workitemsapi.WorkItem{},
141 PageInfo: workitemsapi.PageInfo{HasNextPage: false},
142 },
143 }
145 return &gitlab.Response{}, nil
146 })
147 },
148 wantOutput: "No work items found in OWNER/REPO",
149 },
150 {
151 name: "filters by work item type",
152 args: "--type epic",
153 setupMock: func(tc *gitlabtesting.TestClient) {
154 tc.MockGraphQL.EXPECT().
155 Do(gomock.Any(), gomock.Any(), gomock.Any()).
156 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
157 // Verify that types filter is passed in query variables
158 assert.Contains(t, query.Variables, "types")
159 types, ok := query.Variables["types"].([]string)
160 require.True(t, ok)
161 assert.Equal(t, []string{"EPIC"}, types)
163 resp, _ := response.(*workitemsapi.WorkItemsResponse)
165 resp.Data.Project = &workitemsapi.ProjectWorkItems{
166 WorkItems: workitemsapi.WorkItemsConnection{
167 Nodes: []workitemsapi.WorkItem{
168 {
169 IID: "1",
170 Title: "Q1 Planning Epic",
171 State: "OPEN",
172 WorkItemType: struct {
173 Name string `json:"name"`
174 }{
175 Name: "Epic",
176 },
177 Author: struct {
178 Username string `json:"username"`
179 }{
180 Username: "epicowner",
181 },
182 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/1",
183 },
184 },
185 PageInfo: workitemsapi.PageInfo{
186 HasNextPage: false,
187 },
188 },
189 }
191 return &gitlab.Response{}, nil
192 })
193 },
194 wantOutput: "Q1 Planning Epic",
195 },
196 {
197 name: "json output format",
198 args: "--output json",
199 setupMock: func(tc *gitlabtesting.TestClient) {
200 tc.MockGraphQL.EXPECT().
201 Do(gomock.Any(), gomock.Any(), gomock.Any()).
202 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
203 resp, _ := response.(*workitemsapi.WorkItemsResponse)
205 resp.Data.Project = &workitemsapi.ProjectWorkItems{
206 WorkItems: workitemsapi.WorkItemsConnection{
207 Nodes: []workitemsapi.WorkItem{
208 {
209 IID: "1",
210 Title: "Test Item",
211 State: "OPEN",
212 WorkItemType: struct {
213 Name string `json:"name"`
214 }{
215 Name: "Issue",
216 },
217 Author: struct {
218 Username string `json:"username"`
219 }{
220 Username: "testuser",
221 },
222 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/1",
223 },
224 },
225 PageInfo: workitemsapi.PageInfo{
226 HasNextPage: false,
227 },
228 },
229 }
231 return &gitlab.Response{}, nil
232 })
233 },
234 wantOutput: `"iid":"1"`,
235 },
236 {
237 name: "handles pagination with cursor",
238 args: "--after cursor123",
239 setupMock: func(tc *gitlabtesting.TestClient) {
240 tc.MockGraphQL.EXPECT().
241 Do(gomock.Any(), gomock.Any(), gomock.Any()).
242 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
243 // verify cursor was passed
244 assert.Equal(t, "cursor123", query.Variables["after"])
246 resp, _ := response.(*workitemsapi.WorkItemsResponse)
247 resp.Data.Project = &workitemsapi.ProjectWorkItems{
248 WorkItems: workitemsapi.WorkItemsConnection{
249 Nodes: []workitemsapi.WorkItem{
250 {
251 IID: "2",
252 Title: "Second page item",
253 State: "OPEN",
254 WorkItemType: struct {
255 Name string `json:"name"`
256 }{
257 Name: "Issue",
258 },
259 Author: struct {
260 Username string `json:"username"`
261 }{
262 Username: "user2",
263 },
264 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/2",
265 },
266 },
267 PageInfo: workitemsapi.PageInfo{
268 EndCursor: "cursor456",
269 HasNextPage: true,
270 },
271 },
272 }
273 return &gitlab.Response{}, nil
274 })
275 },
276 wantOutput: `Next page: glab work-items list --after "cursor456"`,
277 },
278 {
279 name: "filters by state - closed",
280 args: "--state closed",
281 setupMock: func(tc *gitlabtesting.TestClient) {
282 tc.MockGraphQL.EXPECT().
283 Do(gomock.Any(), gomock.Any(), gomock.Any()).
284 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
285 // Verify state filter is passed
286 assert.Contains(t, query.Variables, "state")
287 assert.Equal(t, "closed", query.Variables["state"])
289 resp, _ := response.(*workitemsapi.WorkItemsResponse)
291 resp.Data.Project = &workitemsapi.ProjectWorkItems{
292 WorkItems: workitemsapi.WorkItemsConnection{
293 Nodes: []workitemsapi.WorkItem{
294 {
295 IID: "1",
296 Title: "Closed issue",
297 State: "CLOSED",
298 WorkItemType: struct {
299 Name string `json:"name"`
300 }{
301 Name: "Issue",
302 },
303 Author: struct {
304 Username string `json:"username"`
305 }{
306 Username: "testuser",
307 },
308 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/1",
309 },
310 },
311 PageInfo: workitemsapi.PageInfo{HasNextPage: false},
312 },
313 }
315 return &gitlab.Response{}, nil
316 })
317 },
318 wantOutput: "Closed issue",
319 },
320 {
321 name: "filters by state - all (no state filter sent)",
322 args: "--state all",
323 setupMock: func(tc *gitlabtesting.TestClient) {
324 tc.MockGraphQL.EXPECT().
325 Do(gomock.Any(), gomock.Any(), gomock.Any()).
326 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
327 // Verify state filter is NOT passed when state is "all"
328 assert.NotContains(t, query.Variables, "state")
330 resp, _ := response.(*workitemsapi.WorkItemsResponse)
332 resp.Data.Project = &workitemsapi.ProjectWorkItems{
333 WorkItems: workitemsapi.WorkItemsConnection{
334 Nodes: []workitemsapi.WorkItem{
335 {
336 IID: "1",
337 Title: "Open issue",
338 State: "OPEN",
339 WorkItemType: struct {
340 Name string `json:"name"`
341 }{
342 Name: "Issue",
343 },
344 Author: struct {
345 Username string `json:"username"`
346 }{
347 Username: "user1",
348 },
349 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/1",
350 },
351 {
352 IID: "2",
353 Title: "Closed issue",
354 State: "CLOSED",
355 WorkItemType: struct {
356 Name string `json:"name"`
357 }{
358 Name: "Issue",
359 },
360 Author: struct {
361 Username string `json:"username"`
362 }{
363 Username: "user2",
364 },
365 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/2",
366 },
367 },
368 PageInfo: workitemsapi.PageInfo{HasNextPage: false},
369 },
370 }
372 return &gitlab.Response{}, nil
373 })
374 },
375 wantOutput: "Open issue",
376 },
377 {
378 name: "default state is opened",
379 args: "",
380 setupMock: func(tc *gitlabtesting.TestClient) {
381 tc.MockGraphQL.EXPECT().
382 Do(gomock.Any(), gomock.Any(), gomock.Any()).
383 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
384 // Verify default state "opened" is passed
385 assert.Contains(t, query.Variables, "state")
386 assert.Equal(t, "opened", query.Variables["state"])
388 resp, _ := response.(*workitemsapi.WorkItemsResponse)
390 resp.Data.Project = &workitemsapi.ProjectWorkItems{
391 WorkItems: workitemsapi.WorkItemsConnection{
392 Nodes: []workitemsapi.WorkItem{
393 {
394 IID: "1",
395 Title: "Open issue",
396 State: "OPEN",
397 WorkItemType: struct {
398 Name string `json:"name"`
399 }{
400 Name: "Issue",
401 },
402 Author: struct {
403 Username string `json:"username"`
404 }{
405 Username: "user1",
406 },
407 WebURL: "https://gitlab.com/OWNER/REPO/-/work_items/1",
408 },
409 },
410 PageInfo: workitemsapi.PageInfo{HasNextPage: false},
411 },
412 }
414 return &gitlab.Response{}, nil
415 })
416 },
417 wantOutput: "Open issue",
418 },
419 {
420 name: "handles API error",
421 args: "",
422 wantErr: true,
423 setupMock: func(tc *gitlabtesting.TestClient) {
424 tc.MockGraphQL.EXPECT().
425 Do(gomock.Any(), gomock.Any(), gomock.Any()).
426 Return(nil, assert.AnError)
427 },
428 },
429 {
430 name: "handles project not found",
431 args: "",
432 wantErr: true,
433 setupMock: func(tc *gitlabtesting.TestClient) {
434 tc.MockGraphQL.EXPECT().
435 Do(gomock.Any(), gomock.Any(), gomock.Any()).
436 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
437 resp, _ := response.(*workitemsapi.WorkItemsResponse)
439 // Return nil project to trigger "project not found" error
440 resp.Data.Project = nil
442 return &gitlab.Response{}, nil
443 })
444 },
445 },
446 }
448 for _, tt := range tests {
449 t.Run(tt.name, func(t *testing.T) {
450 // Create test client with mocks
451 tc := gitlabtesting.NewTestClient(t)
452 tt.setupMock(tc)
454 // Setup command for test
455 exec := cmdtest.SetupCmdForTest(
456 t,
457 NewCmd,
458 false,
459 cmdtest.WithGitLabClient(tc.Client),
460 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
461 )
463 // Execute command
464 out, err := exec(tt.args)
466 // Assertions
467 if tt.wantErr {
468 require.Error(t, err)
469 } else {
470 require.NoError(t, err)
471 assert.Contains(t, out.OutBuf.String(), tt.wantOutput)
472 }
473 })
474 }
477func TestWorkItemsList_FlagValidation(t *testing.T) {
478 // NOTE: No t.Parallel() here due to Viper global state issues
480 tests := []struct {
481 name string
482 args string
483 wantErr string
484 }{
485 {
486 name: "invalid output format",
487 args: "--output xml",
488 wantErr: "must be one of",
489 },
490 {
491 name: "empty type in comma-separated list",
492 args: "--type epic,",
493 wantErr: "empty work item type",
494 },
495 {
496 name: "whitespace only type",
497 args: "--type ' '",
498 wantErr: "empty work item type",
499 },
500 {
501 name: "invalid per-page value - too high",
502 args: "--per-page 101",
503 wantErr: "--per-page must be between 1 and 100",
504 },
505 {
506 name: "invalid per-page value - too low",
507 args: "--per-page 0",
508 wantErr: "--per-page must be between 1 and 100",
509 },
510 {
511 name: "invalid page value",
512 args: "--page 0",
513 wantErr: "unknown flag: --page",
514 },
515 {
516 name: "invalid state value",
517 args: "--state invalid",
518 wantErr: "--state must be one of: opened, closed, all",
519 },
520 {
521 name: "invalid relative date unit",
522 args: "--created-after -7h",
523 wantErr: `invalid argument "-7h" for "--created-after" flag`,
524 },
525 {
526 name: "relative date amount out of range",
527 args: "--due-before 10000d",
528 wantErr: "relative date amount must be between -9999 and 9999",
529 },
530 {
531 name: "invalid absolute date",
532 args: "--updated-before 2026-02-30",
533 wantErr: `invalid argument "2026-02-30" for "--updated-before" flag`,
534 },
535 {
536 name: "closed date filter with opened state",
537 args: "--state opened --closed-after -7d",
538 wantErr: "--closed-after and --closed-before need --state closed or all",
539 },
540 }
542 for _, tt := range tests {
543 t.Run(tt.name, func(t *testing.T) {
544 exec := cmdtest.SetupCmdForTest(
545 t,
546 NewCmd,
547 false,
548 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
549 )
551 _, err := exec(tt.args)
552 require.Error(t, err)
553 assert.Contains(t, err.Error(), tt.wantErr)
554 })
555 }
558func TestWorkItemsList_DateFilters(t *testing.T) {
559 tests := []struct {
560 name string
561 args string
562 assertVars func(t *testing.T, query gitlab.GraphQLQuery)
563 group bool
564 hasNext bool
565 wantOutput string
566 }{
567 {
568 name: "no date filters",
569 args: "",
570 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
571 t.Helper()
572 assert.NotContains(t, query.Query, "relativeDateFilters")
573 assert.NotContains(t, query.Query, "createdAfter")
574 assert.NotContains(t, query.Variables, "relativeDateFilters")
575 },
576 },
577 {
578 name: "relative date filters",
579 args: "--created-after -7d --due-before 2w",
580 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
581 t.Helper()
582 assert.Contains(t, query.Query, "$relativeDateFilters: WorkItemRelativeDateFiltersInput")
583 assert.Contains(t, query.Query, "relativeDateFilters: $relativeDateFilters")
584 assert.Equal(t, map[workitemsapi.DateField]workitemsapi.RelativeDate{
585 workitemsapi.CreatedAfter: {Amount: -7, Unit: workitemsapi.RelativeDateUnitDay},
586 workitemsapi.DueBefore: {Amount: 2, Unit: workitemsapi.RelativeDateUnitWeek},
587 }, query.Variables["relativeDateFilters"])
588 assert.NotContains(t, query.Variables, "createdAfter")
589 },
590 },
591 {
592 name: "absolute date filters",
593 args: "--closed-after 2026-01-01 --updated-before 2026-04-01T12:00:00Z",
594 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
595 t.Helper()
596 assert.Contains(t, query.Query, "$closedAfter: Time")
597 assert.Contains(t, query.Query, "closedAfter: $closedAfter")
598 assert.Equal(t, "2026-01-01", query.Variables["closedAfter"])
599 assert.Equal(t, "2026-04-01T12:00:00Z", query.Variables["updatedBefore"])
600 assert.NotContains(t, query.Variables, "relativeDateFilters")
601 },
602 },
603 {
604 name: "all absolute date flags map to their fields",
605 args: "--state all --created-after 2026-01-01 --created-before 2026-01-02 --updated-after 2026-01-03 --updated-before 2026-01-04 " +
606 "--closed-after 2026-01-05 --closed-before 2026-01-06 --due-after 2026-01-07 --due-before 2026-01-08",
607 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
608 t.Helper()
609 assert.Equal(t, map[string]any{
610 "projectPath": "OWNER/REPO",
611 "first": int64(20),
612 "createdAfter": "2026-01-01",
613 "createdBefore": "2026-01-02",
614 "updatedAfter": "2026-01-03",
615 "updatedBefore": "2026-01-04",
616 "closedAfter": "2026-01-05",
617 "closedBefore": "2026-01-06",
618 "dueAfter": "2026-01-07",
619 "dueBefore": "2026-01-08",
620 }, query.Variables)
621 },
622 },
623 {
624 name: "all relative date flags map to their fields",
625 args: "--state all --created-after -1d --created-before -2d --updated-after -3d --updated-before -4d " +
626 "--closed-after -5d --closed-before -6d --due-after 7d --due-before 8d",
627 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
628 t.Helper()
629 assert.Equal(t, map[string]any{
630 "projectPath": "OWNER/REPO",
631 "first": int64(20),
632 "relativeDateFilters": map[workitemsapi.DateField]workitemsapi.RelativeDate{
633 workitemsapi.CreatedAfter: {Amount: -1, Unit: workitemsapi.RelativeDateUnitDay},
634 workitemsapi.CreatedBefore: {Amount: -2, Unit: workitemsapi.RelativeDateUnitDay},
635 workitemsapi.UpdatedAfter: {Amount: -3, Unit: workitemsapi.RelativeDateUnitDay},
636 workitemsapi.UpdatedBefore: {Amount: -4, Unit: workitemsapi.RelativeDateUnitDay},
637 workitemsapi.ClosedAfter: {Amount: -5, Unit: workitemsapi.RelativeDateUnitDay},
638 workitemsapi.ClosedBefore: {Amount: -6, Unit: workitemsapi.RelativeDateUnitDay},
639 workitemsapi.DueAfter: {Amount: 7, Unit: workitemsapi.RelativeDateUnitDay},
640 workitemsapi.DueBefore: {Amount: 8, Unit: workitemsapi.RelativeDateUnitDay},
641 },
642 }, query.Variables)
643 },
644 },
645 {
646 name: "closed date filter implies closed state",
647 args: "--closed-before -1d",
648 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
649 t.Helper()
650 assert.Equal(t, "closed", query.Variables["state"])
651 },
652 },
653 {
654 name: "closed date filter keeps explicit all state",
655 args: "--state all --closed-after -7d",
656 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
657 t.Helper()
658 assert.NotContains(t, query.Variables, "state")
659 },
660 },
661 {
662 name: "group scope date filters",
663 args: "-g test-group --created-after -7d --closed-before 2026-04-01",
664 group: true,
665 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
666 t.Helper()
667 assert.Contains(t, query.Query, "query ListGroupWorkItems(")
668 assert.Contains(t, query.Query, "$closedBefore: Time")
669 assert.Contains(t, query.Query, "closedBefore: $closedBefore")
670 assert.Contains(t, query.Query, "$relativeDateFilters: WorkItemRelativeDateFiltersInput")
671 assert.Contains(t, query.Query, "relativeDateFilters: $relativeDateFilters")
672 assert.Equal(t, "2026-04-01", query.Variables["closedBefore"])
673 assert.Equal(t, map[workitemsapi.DateField]workitemsapi.RelativeDate{
674 workitemsapi.CreatedAfter: {Amount: -7, Unit: workitemsapi.RelativeDateUnitDay},
675 }, query.Variables["relativeDateFilters"])
676 },
677 },
678 {
679 name: "next page command keeps relative dates",
680 args: "--updated-after -1y --updated-before -1m",
681 hasNext: true,
682 assertVars: func(t *testing.T, query gitlab.GraphQLQuery) {
683 t.Helper()
684 assert.Contains(t, query.Variables, "relativeDateFilters")
685 },
686 wantOutput: `Next page: glab work-items list --updated-after -1y --updated-before -1m --after "cursor456"`,
687 },
688 }
690 for _, tt := range tests {
691 t.Run(tt.name, func(t *testing.T) {
692 tc := gitlabtesting.NewTestClient(t)
693 tc.MockGraphQL.EXPECT().
694 Do(gomock.Any(), gomock.Any(), gomock.Any()).
695 DoAndReturn(func(query gitlab.GraphQLQuery, response any, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
696 tt.assertVars(t, query)
698 conn := workitemsapi.WorkItemsConnection{
699 Nodes: []workitemsapi.WorkItem{
700 {IID: "1", Title: "Recent item", State: "OPEN"},
701 },
702 PageInfo: workitemsapi.PageInfo{EndCursor: "cursor456", HasNextPage: tt.hasNext},
703 }
704 resp, _ := response.(*workitemsapi.WorkItemsResponse)
705 if tt.group {
706 resp.Data.Group = &workitemsapi.GroupWorkItems{WorkItems: conn}
707 } else {
708 resp.Data.Project = &workitemsapi.ProjectWorkItems{WorkItems: conn}
709 }
710 return &gitlab.Response{}, nil
711 })
713 exec := cmdtest.SetupCmdForTest(
714 t,
715 NewCmd,
716 false,
717 cmdtest.WithGitLabClient(tc.Client),
718 cmdtest.WithBaseRepo("OWNER", "REPO", glinstance.DefaultHostname),
719 )
721 out, err := exec(tt.args)
723 require.NoError(t, err)
724 assert.Contains(t, out.OutBuf.String(), "Recent item")
725 if tt.wantOutput != "" {
726 assert.Contains(t, out.OutBuf.String(), tt.wantOutput)
727 }
728 })
729 }
Diagnostics8 git calls · 307 ms
CallStatusSizeTime0307 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=3
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
fetchcombine:blob:none+tree:2 · deepen 12004.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=4273
git.response.cache=HIT
git.response.duration_ms=2
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.8 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=1857
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1857
git.pkt.payload.max=1830
git.sideband.band1.bytes=1830
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1830
git.pack.trailer=fb03183b7909876778f740d196d7516811003517
Open pack map
fetchtree:0200317 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=317
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=33cd62a3f1bc55e6bd56a9b96f181ff12c30955a
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=317
git.pkt.payload.max=290
git.sideband.band1.bytes=290
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=290
git.pack.trailer=5711d3cc007ef3bd902f87854e977c46d0913d04
Open pack map
fetchtree:0200134 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=294
git.response.bytes=134
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=a26639bcb3dad59f922343bfee14e5625ce7950a
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=134
git.pkt.payload.max=107
git.sideband.band1.bytes=107
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=107
git.pack.trailer=692a20cead216b96f20a284440e1aa9f3e1aa9ae
Open pack map
fetch2003.3 KiB294 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3356
git.response.cache=MISS
git.response.duration_ms=294
git.fetch.wants=30ccd369c9ec96dfc6de7ba06c4fdff9eca5942f
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=3356
git.pkt.payload.max=3329
git.sideband.band1.bytes=3329
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
a5e2ba65cf66cf46
Request
a19d6ddb…
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