GitLabgitlab-org

cli

main
ply6 git calls42 ms99 KiB5 cachedprotocol v2
962 lines23 KiBRaw
1//go:build !integration
3package git
5import (
6 "errors"
7 "os"
8 "path"
9 "path/filepath"
10 "slices"
11 "testing"
13 "github.com/stretchr/testify/assert"
14 "github.com/stretchr/testify/require"
15 "go.uber.org/mock/gomock"
17 "gitlab.com/gitlab-org/cli/internal/config"
18 git_testing "gitlab.com/gitlab-org/cli/internal/git/testing"
21func Test_StackRemoveRef(t *testing.T) {
22 type args struct {
23 stack Stack
24 remove StackRef
25 }
26 tests := []struct {
27 name string
28 args args
29 expected map[string]StackRef
30 }{
31 {
32 name: "with multiple files",
33 args: args{
34 remove: StackRef{SHA: "456", Prev: "123", Next: "789", Branch: "Branch2"},
35 stack: Stack{
36 Title: "sweet-title-123",
37 Refs: map[string]StackRef{
38 "123": {SHA: "123", Prev: "", Next: "456", Branch: "Branch1"},
39 "456": {SHA: "456", Prev: "123", Next: "789", Branch: "Branch2"},
40 "789": {SHA: "789", Prev: "456", Next: "", Branch: "Branch3"},
41 },
42 },
43 },
44 expected: map[string]StackRef{
45 "123": {SHA: "123", Prev: "", Next: "789", Branch: "Branch1"},
46 "789": {SHA: "789", Prev: "123", Next: "", Branch: "Branch3"},
47 },
48 },
49 {
50 name: "with 1 file",
51 args: args{
52 stack: Stack{
53 Title: "sweet-title-123",
54 Refs: map[string]StackRef{"123": {SHA: "123", Prev: "", Next: "", Branch: "Branch1"}},
55 },
56 remove: StackRef{SHA: "123", Prev: "", Next: "", Branch: "Branch1"},
57 },
58 expected: map[string]StackRef{},
59 },
60 {
61 name: "large number",
62 args: args{
63 stack: Stack{
64 Title: "title-123",
65 Refs: map[string]StackRef{
66 "1": {SHA: "1", Prev: "", Next: "2", Branch: "Branch1"},
67 "2": {SHA: "2", Prev: "1", Next: "3", Branch: "Branch2"},
68 "3": {SHA: "3", Prev: "2", Next: "4", Branch: "Branch3"},
69 "4": {SHA: "4", Prev: "3", Next: "5", Branch: "Branch4"},
70 "5": {SHA: "5", Prev: "4", Next: "6", Branch: "Branch5"},
71 "6": {SHA: "6", Prev: "5", Next: "7", Branch: "Branch6"},
72 "7": {SHA: "7", Prev: "6", Next: "8", Branch: "Branch7"},
73 "8": {SHA: "8", Prev: "7", Next: "9", Branch: "Branch8"},
74 "9": {SHA: "9", Prev: "8", Next: "10", Branch: "Branch9"},
75 "10": {SHA: "10", Prev: "9", Next: "11", Branch: "Branch10"},
76 "11": {SHA: "11", Prev: "10", Next: "12", Branch: "Branch11"},
77 "12": {SHA: "12", Prev: "11", Next: "13", Branch: "Branch12"},
78 "13": {SHA: "13", Prev: "12", Next: "", Branch: "Branch13"},
79 },
80 },
81 remove: StackRef{SHA: "11", Prev: "10", Next: "12", Branch: "Branch11"},
82 },
83 expected: map[string]StackRef{
84 "1": {SHA: "1", Prev: "", Next: "2", Branch: "Branch1"},
85 "2": {SHA: "2", Prev: "1", Next: "3", Branch: "Branch2"},
86 "3": {SHA: "3", Prev: "2", Next: "4", Branch: "Branch3"},
87 "4": {SHA: "4", Prev: "3", Next: "5", Branch: "Branch4"},
88 "5": {SHA: "5", Prev: "4", Next: "6", Branch: "Branch5"},
89 "6": {SHA: "6", Prev: "5", Next: "7", Branch: "Branch6"},
90 "7": {SHA: "7", Prev: "6", Next: "8", Branch: "Branch7"},
91 "8": {SHA: "8", Prev: "7", Next: "9", Branch: "Branch8"},
92 "9": {SHA: "9", Prev: "8", Next: "10", Branch: "Branch9"},
93 "10": {SHA: "10", Prev: "9", Next: "12", Branch: "Branch10"},
94 "12": {SHA: "12", Prev: "10", Next: "13", Branch: "Branch12"},
95 "13": {SHA: "13", Prev: "12", Next: "", Branch: "Branch13"},
96 },
97 },
98 }
99 for _, tt := range tests {
100 t.Run(tt.name, func(t *testing.T) {
101 InitGitRepoWithCommit(t)
103 ctrl := gomock.NewController(t)
104 mockCmd := git_testing.NewMockGitRunner(ctrl)
106 if tt.args.remove.Prev != "" {
107 prevBranch := tt.args.stack.Refs[tt.args.remove.Prev].Branch
108 mockCmd.EXPECT().Git([]string{"checkout", prevBranch}).Return("main", nil)
109 mockCmd.EXPECT().Git([]string{"branch", "-D", tt.args.remove.Branch})
110 }
112 err := CreateRefFiles(tt.args.stack.Refs, tt.args.stack.Title)
113 require.NoError(t, err)
115 err = tt.args.stack.RemoveRef(tt.args.remove, mockCmd)
116 require.NoError(t, err)
118 require.Equal(t, tt.expected, tt.args.stack.Refs)
120 stackLoc, locErr := StackLocation()
121 require.NoError(t, locErr)
122 wantpath := path.Join(stackLoc, tt.args.remove.Branch, ".json")
123 require.False(t, config.CheckFileExists(wantpath))
124 })
125 }
128func Test_AddStackBaseBranch(t *testing.T) {
129 tests := []struct {
130 name string
131 title string
132 branch string
133 }{
134 {
135 name: "successfully add branch",
136 title: "test-stack",
137 branch: "main",
138 },
139 {
140 name: "successfully add custom branch",
141 title: "custom-stack",
142 branch: "feature/branch",
143 },
144 }
146 for _, tt := range tests {
147 t.Run(tt.name, func(t *testing.T) {
148 InitGitRepo(t)
150 _, err := AddStackRefDir(tt.title)
151 require.NoError(t, err)
153 err = AddStackBaseBranch(tt.title, tt.branch)
154 require.NoError(t, err)
156 stackRoot, err := StackRootDir(tt.title)
157 require.NoError(t, err)
159 filename := filepath.Join(stackRoot, BaseBranchFile)
160 require.FileExists(t, filename)
162 content, err := os.ReadFile(filename)
163 require.NoError(t, err)
164 assert.Equal(t, tt.branch, string(content))
165 })
166 }
169func Test_StackLast(t *testing.T) {
170 tests := []struct {
171 name string
172 mockRefs map[string]StackRef
173 expected StackRef
174 }{
175 {
176 name: "Find last ref",
177 mockRefs: map[string]StackRef{
178 "sha1": {Next: "sha2", SHA: "sha1"},
179 "sha2": {Prev: "sha1", Next: "sha3", SHA: "sha2"},
180 "sha3": {Prev: "sha2", SHA: "sha3"},
181 },
182 expected: StackRef{Prev: "sha2", SHA: "sha3"},
183 },
184 {
185 name: "No refs",
186 mockRefs: map[string]StackRef{},
187 expected: StackRef{},
188 },
189 }
191 for _, tt := range tests {
192 t.Run(tt.name, func(t *testing.T) {
193 s := &Stack{Refs: tt.mockRefs}
194 got := s.Last()
196 require.Equal(t, tt.expected, got)
197 })
198 }
201func Test_StackFirst(t *testing.T) {
202 tests := []struct {
203 name string
204 mockRefs map[string]StackRef
205 expected StackRef
206 }{
207 {
208 name: "Find first ref",
209 mockRefs: map[string]StackRef{
210 "sha1": {Next: "sha2", SHA: "sha1"},
211 "sha2": {Prev: "sha1", Next: "sha3", SHA: "sha2"},
212 "sha3": {Prev: "sha2", SHA: "sha3"},
213 },
214 expected: StackRef{Next: "sha2", SHA: "sha1"},
215 },
216 {
217 name: "No refs",
218 mockRefs: map[string]StackRef{},
219 expected: StackRef{},
220 },
221 }
223 for _, tt := range tests {
224 t.Run(tt.name, func(t *testing.T) {
225 s := &Stack{Refs: tt.mockRefs}
226 got := s.First()
228 require.Equal(t, tt.expected, got)
229 })
230 }
233func Test_StackBaseBranch(t *testing.T) {
234 tests := []struct {
235 name string
236 title string
237 setupFile bool
238 branchInFile string
239 mockRemoteShow string
240 gitError error
241 expectedBranch string
242 expectedError bool
243 }{
244 {
245 name: "successfully read branch from file",
246 title: "test-stack",
247 setupFile: true,
248 branchInFile: "custom-branch",
249 expectedBranch: "custom-branch",
250 expectedError: false,
251 },
252 {
253 name: "get default branch when file doesn't exist",
254 title: "test-stack",
255 setupFile: false,
256 mockRemoteShow: `* remote origin
257 Fetch URL: https://gitlab.org/gitlab-org/cli.git
258 Push URL: https://gitlab.org/gitlab-org/cli.git
259 HEAD branch: main
260 Remote branches:`,
261 expectedBranch: "main",
262 expectedError: false,
263 },
264 {
265 name: "error getting remote data",
266 title: "test-stack",
267 setupFile: false,
268 gitError: errors.New("git command failed"),
269 expectedError: true,
270 },
271 }
273 for _, tt := range tests {
274 t.Run(tt.name, func(t *testing.T) {
275 InitGitRepo(t)
277 stack := Stack{
278 Title: tt.title,
279 Refs: make(map[string]StackRef),
280 }
282 ctrl := gomock.NewController(t)
283 mockGitRunner := git_testing.NewMockGitRunner(ctrl)
285 if tt.setupFile {
286 _, err := AddStackRefDir(tt.title)
287 require.NoError(t, err)
289 err = AddStackBaseBranch(tt.title, tt.branchInFile)
290 require.NoError(t, err)
291 } else {
292 if tt.gitError != nil {
293 mockGitRunner.EXPECT().
294 Git([]string{"remote", "show", DefaultRemote}).
295 Return("", tt.gitError)
296 } else {
297 mockGitRunner.EXPECT().
298 Git([]string{"remote", "show", DefaultRemote}).
299 Return(tt.mockRemoteShow, nil)
300 }
301 }
303 branch, err := stack.BaseBranch(mockGitRunner)
305 if tt.expectedError {
306 require.Error(t, err)
307 return
308 }
310 require.NoError(t, err)
311 assert.Equal(t, tt.expectedBranch, branch)
312 })
313 }
316func Test_StackEmpty(t *testing.T) {
317 s := Stack{Refs: make(map[string]StackRef)}
318 if !s.Empty() {
319 t.Errorf("Expected empty stack, but got non-empty")
320 }
322 s.Refs["sha"] = StackRef{}
323 if s.Empty() {
324 t.Errorf("Expected non-empty stack, but got empty")
325 }
328func Test_StackRemoveBranch(t *testing.T) {
329 tests := []struct {
330 name string
331 stack Stack
332 ref StackRef
333 wantErr bool
334 expectBaseBranch bool
335 }{
336 {
337 name: "remove single ref",
338 stack: Stack{
339 Title: "test-stack",
340 Refs: map[string]StackRef{"sha1": {SHA: "sha1", Branch: "branch123"}},
341 },
342 ref: StackRef{SHA: "sha1", Branch: "branch123"},
343 expectBaseBranch: true,
344 },
345 {
346 name: "remove first ref",
347 stack: Stack{
348 Title: "test-stack",
349 Refs: map[string]StackRef{
350 "sha1": {SHA: "sha1", Next: "sha2", Branch: "branch123"},
351 "sha2": {SHA: "sha2", Prev: "sha1", Branch: "branch456"},
352 },
353 },
354 ref: StackRef{SHA: "sha1", Next: "sha2", Branch: "branch123"},
355 expectBaseBranch: true,
356 },
357 {
358 name: "remove middle ref",
359 stack: Stack{
360 Title: "test-stack",
361 Refs: map[string]StackRef{
362 "sha1": {SHA: "sha1", Next: "sha2", Branch: "branch123"},
363 "sha2": {SHA: "sha2", Prev: "sha1", Next: "sha3", Branch: "branch456"},
364 "sha3": {SHA: "sha3", Prev: "sha2", Branch: "branch789"},
365 },
366 },
367 ref: StackRef{SHA: "sha2", Prev: "sha1", Next: "sha3", Branch: "branch456"},
368 expectBaseBranch: false,
369 },
370 {
371 name: "remove last ref",
372 stack: Stack{
373 Title: "test-stack",
374 Refs: map[string]StackRef{
375 "sha1": {SHA: "sha1", Next: "sha2", Branch: "branch123"},
376 "sha2": {SHA: "sha2", Prev: "sha1", Branch: "branch456"},
377 },
378 },
379 ref: StackRef{SHA: "sha2", Prev: "sha1", Branch: "branch456"},
380 expectBaseBranch: false,
381 },
382 }
384 for _, tt := range tests {
385 t.Run(tt.name, func(t *testing.T) {
386 InitGitRepoWithCommit(t)
388 ctrl := gomock.NewController(t)
389 mockCmd := git_testing.NewMockGitRunner(ctrl)
391 _, err := AddStackRefDir(tt.stack.Title)
392 require.NoError(t, err)
394 err = AddStackBaseBranch(tt.stack.Title, "base")
395 require.NoError(t, err)
397 if tt.ref.Prev != "" {
398 prevBranch := tt.stack.Refs[tt.ref.Prev].Branch
399 mockCmd.EXPECT().Git([]string{"checkout", prevBranch})
400 mockCmd.EXPECT().Git([]string{"branch", "-D", tt.ref.Branch})
401 } else {
402 mockCmd.EXPECT().Git([]string{"checkout", "base"})
403 mockCmd.EXPECT().Git([]string{"branch", "-D", tt.ref.Branch})
404 }
405 //
406 err = tt.stack.RemoveBranch(tt.ref, mockCmd)
407 require.NoError(t, err)
408 })
409 }
412func Test_GatherStackRefs(t *testing.T) {
413 type args struct {
414 title string
415 }
416 tests := []struct {
417 name string
418 args args
419 stacks []StackRef
420 expected Stack
421 wantErr bool
422 }{
423 {
424 name: "with multiple files",
425 args: args{title: "sweet-title-123"},
426 stacks: []StackRef{
427 {SHA: "456", Prev: "123", Next: "789"},
428 {SHA: "123", Prev: "", Next: "456"},
429 {SHA: "789", Prev: "456", Next: ""},
430 },
431 expected: Stack{
432 Refs: map[string]StackRef{
433 "123": {SHA: "123", Prev: "", Next: "456"},
434 "456": {SHA: "456", Prev: "123", Next: "789"},
435 "789": {SHA: "789", Prev: "456", Next: ""},
436 },
437 Title: "sweet-title-123",
438 },
439 },
440 {
441 name: "with 1 file",
442 args: args{title: "sweet-title-123"},
443 stacks: []StackRef{
444 {SHA: "123", Prev: "", Next: ""},
445 },
446 expected: Stack{
447 Refs: map[string]StackRef{
448 "123": {SHA: "123", Prev: "", Next: ""},
449 },
450 Title: "sweet-title-123",
451 },
452 },
453 {
454 name: "with bad start ref data",
455 args: args{title: "sweet-title-123"},
456 stacks: []StackRef{
457 {SHA: "123", Prev: "", Next: "456"},
458 {SHA: "456", Prev: "", Next: ""},
459 },
460 expected: Stack{},
461 wantErr: true,
462 },
463 {
464 name: "with bad end ref data",
465 args: args{title: "sweet-title-123"},
466 stacks: []StackRef{
467 {SHA: "123", Prev: "", Next: ""},
468 {SHA: "456", Prev: "123", Next: ""},
469 },
470 expected: Stack{},
471 wantErr: true,
472 },
473 {
474 name: "with multiple start refs",
475 args: args{title: "sweet-title-123"},
476 stacks: []StackRef{
477 {SHA: "123", Prev: "", Next: "456"},
478 {SHA: "456", Prev: "", Next: ""},
479 },
480 expected: Stack{},
481 wantErr: true,
482 },
483 {
484 name: "with multiple end refs",
485 args: args{title: "sweet-title-123"},
486 stacks: []StackRef{
487 {SHA: "123", Prev: "", Next: ""},
488 {SHA: "456", Prev: "123", Next: ""},
489 },
490 expected: Stack{},
491 wantErr: true,
492 },
493 {
494 name: "without start ref",
495 args: args{title: "sweet-title-123"},
496 stacks: []StackRef{
497 {SHA: "123", Prev: "456", Next: "456"},
498 {SHA: "456", Prev: "456", Next: ""},
499 },
500 expected: Stack{},
501 wantErr: true,
502 },
503 {
504 name: "without end ref",
505 args: args{title: "sweet-title-123"},
506 stacks: []StackRef{
507 {SHA: "123", Prev: "", Next: "456"},
508 {SHA: "456", Prev: "123", Next: "123"},
509 },
510 expected: Stack{},
511 wantErr: true,
512 },
513 }
514 for _, tt := range tests {
515 t.Run(tt.name, func(t *testing.T) {
516 InitGitRepo(t)
518 for _, stack := range tt.stacks {
519 err := AddStackRefFile(tt.args.title, stack)
520 require.NoError(t, err)
521 }
523 stack, err := GatherStackRefs(tt.args.title)
525 if tt.wantErr {
526 require.Error(t, err)
527 } else {
528 require.NoError(t, err)
529 }
531 require.Equal(t, tt.expected, stack)
532 })
533 }
536func Test_adjustAdjacentRefs(t *testing.T) {
537 type args struct {
538 title string
539 adjust StackRef
540 }
541 tests := []struct {
542 name string
543 args args
544 stacks []StackRef
545 expected Stack
546 wantErr bool
547 }{
548 {
549 name: "with multiple files",
550 args: args{
551 title: "sweet-title-123",
552 adjust: StackRef{SHA: "456", Prev: "123", Next: "789"},
553 },
554 stacks: []StackRef{
555 {SHA: "456", Prev: "123", Next: "789"},
556 {SHA: "123", Prev: "", Next: "456"},
557 {SHA: "789", Prev: "456", Next: ""},
558 },
559 expected: Stack{
560 Refs: map[string]StackRef{
561 "123": {SHA: "123", Prev: "", Next: "789"},
562 "456": {SHA: "456", Prev: "123", Next: "789"},
563 "789": {SHA: "789", Prev: "123", Next: ""},
564 },
565 Title: "sweet-title-123",
566 },
567 },
568 {
569 name: "with multiple files, beginning ref",
570 args: args{
571 title: "sweet-title-123",
572 adjust: StackRef{SHA: "123", Prev: "", Next: "456"},
573 },
574 stacks: []StackRef{
575 {SHA: "456", Prev: "123", Next: "789"},
576 {SHA: "123", Prev: "", Next: "456"},
577 {SHA: "789", Prev: "456", Next: ""},
578 },
579 expected: Stack{
580 Refs: map[string]StackRef{
581 "123": {SHA: "123", Prev: "", Next: "456"},
582 "456": {SHA: "456", Prev: "", Next: "789"},
583 "789": {SHA: "789", Prev: "456", Next: ""},
584 },
585 Title: "sweet-title-123",
586 },
587 },
588 {
589 name: "with multiple files, end ref",
590 args: args{
591 title: "sweet-title-123",
592 adjust: StackRef{SHA: "789", Prev: "456", Next: ""},
593 },
594 stacks: []StackRef{
595 {SHA: "123", Prev: "", Next: "456"},
596 {SHA: "456", Prev: "123", Next: "789"},
597 {SHA: "789", Prev: "456", Next: ""},
598 },
599 expected: Stack{
600 Refs: map[string]StackRef{
601 "123": {SHA: "123", Prev: "", Next: "456"},
602 "456": {SHA: "456", Prev: "123", Next: ""},
603 "789": {SHA: "789", Prev: "456", Next: ""},
604 },
605 Title: "sweet-title-123",
606 },
607 },
608 {
609 name: "with 1 file",
610 args: args{
611 title: "sweet-title-123",
612 adjust: StackRef{SHA: "123", Prev: "", Next: ""},
613 },
614 stacks: []StackRef{
615 {SHA: "123", Prev: "", Next: ""},
616 },
617 expected: Stack{
618 Refs: map[string]StackRef{
619 "123": {SHA: "123", Prev: "", Next: ""},
620 },
621 Title: "sweet-title-123",
622 },
623 },
624 }
625 for _, tt := range tests {
626 t.Run(tt.name, func(t *testing.T) {
627 InitGitRepo(t)
629 for _, stack := range tt.stacks {
630 err := AddStackRefFile(tt.args.title, stack)
631 require.NoError(t, err)
632 }
634 originalStack, err := GatherStackRefs(tt.args.title)
635 require.NoError(t, err)
637 err = originalStack.adjustAdjacentRefs(tt.args.adjust)
638 require.NoError(t, err)
640 if tt.wantErr {
641 require.Error(t, err)
642 } else {
643 require.NoError(t, err)
644 }
646 require.Equal(t, tt.expected.Refs, originalStack.Refs)
647 })
648 }
651func Test_validateStackRefs(t *testing.T) {
652 tests := []struct {
653 name string
654 stack Stack
655 wantErr bool
656 }{
657 {
658 name: "valid stack",
659 stack: Stack{
660 Refs: map[string]StackRef{
661 "1": {SHA: "1", Prev: "", Next: "2"},
662 "2": {SHA: "2", Prev: "1", Next: "3"},
663 "3": {SHA: "3", Prev: "2", Next: ""},
664 },
665 },
666 wantErr: false,
667 },
668 {
669 name: "multiple start refs",
670 stack: Stack{
671 Refs: map[string]StackRef{
672 "1": {SHA: "1", Prev: "", Next: "2"},
673 "2": {SHA: "2", Prev: "", Next: "3"},
674 "3": {SHA: "3", Prev: "2", Next: ""},
675 },
676 },
677 wantErr: true,
678 },
679 {
680 name: "multiple end refs",
681 stack: Stack{
682 Refs: map[string]StackRef{
683 "1": {SHA: "1", Prev: "", Next: "2"},
684 "2": {SHA: "2", Prev: "1", Next: ""},
685 "3": {SHA: "3", Prev: "2", Next: ""},
686 },
687 },
688 wantErr: true,
689 },
690 {
691 name: "empty stack",
692 stack: Stack{
693 Refs: map[string]StackRef{},
694 },
695 wantErr: false,
696 },
697 }
699 for _, tt := range tests {
700 t.Run(tt.name, func(t *testing.T) {
701 err := validateStackRefs(tt.stack)
702 if tt.wantErr {
703 require.Error(t, err)
704 } else {
705 require.NoError(t, err)
706 }
707 })
708 }
711func TestStack_IndexAt(t *testing.T) {
712 tests := []struct {
713 name string
714 stack Stack
715 ref StackRef
716 expected int
717 }{
718 {
719 name: "Find existing ref in the middle",
720 stack: Stack{
721 Refs: map[string]StackRef{
722 "sha1": {SHA: "sha1", Branch: "branch1", Next: "sha2", Prev: ""},
723 "sha2": {SHA: "sha2", Branch: "branch2", Next: "sha3", Prev: "sha1"},
724 "sha3": {SHA: "sha3", Branch: "branch3", Next: "", Prev: "sha2"},
725 },
726 },
727 ref: StackRef{SHA: "sha2", Branch: "branch2", Next: "sha3", Prev: "sha1"},
728 expected: 1,
729 },
730 {
731 name: "Find first ref",
732 stack: Stack{
733 Refs: map[string]StackRef{
734 "sha1": {SHA: "sha1", Branch: "branch1", Next: "sha2", Prev: ""},
735 "sha2": {SHA: "sha2", Branch: "branch2", Next: "", Prev: "sha1"},
736 },
737 },
738 ref: StackRef{SHA: "sha1", Branch: "branch1", Next: "sha2", Prev: ""},
739 expected: 0,
740 },
741 {
742 name: "Find last ref",
743 stack: Stack{
744 Refs: map[string]StackRef{
745 "sha1": {SHA: "sha1", Branch: "branch1", Next: "sha2", Prev: ""},
746 "sha2": {SHA: "sha2", Branch: "branch2", Next: "sha3", Prev: "sha1"},
747 "sha3": {SHA: "sha3", Branch: "branch3", Next: "", Prev: "sha2"},
748 },
749 },
750 ref: StackRef{SHA: "sha3", Branch: "branch3", Next: "", Prev: "sha2"},
751 expected: 2,
752 },
753 {
754 name: "Ref not found",
755 stack: Stack{
756 Refs: map[string]StackRef{
757 "sha1": {SHA: "sha1", Branch: "branch1", Next: "sha2", Prev: ""},
758 "sha2": {SHA: "sha2", Branch: "branch2", Next: "sha3", Prev: "sha1"},
759 "sha3": {SHA: "sha3", Branch: "branch3", Next: "", Prev: "sha2"},
760 },
761 },
762 ref: StackRef{SHA: "sha4", Branch: "branch3"},
763 expected: -1,
764 },
765 {
766 name: "Empty stack",
767 stack: Stack{},
768 ref: StackRef{SHA: "sha1", Branch: "branch1"},
769 expected: -1,
770 },
771 }
773 for _, tt := range tests {
774 t.Run(tt.name, func(t *testing.T) {
775 result := tt.stack.IndexAt(tt.ref)
776 require.Equal(t, tt.expected, result)
777 })
778 }
781func TestStack_Iter(t *testing.T) {
782 tests := []struct {
783 name string
784 stack Stack
785 expectedIterations int
786 }{
787 {
788 name: "empty stack",
789 stack: Stack{},
790 expectedIterations: 0,
791 },
792 {
793 name: "single ref stack",
794 stack: Stack{
795 Refs: map[string]StackRef{
796 "abc": {SHA: "abc", Prev: "", Next: ""},
797 },
798 },
799 expectedIterations: 1,
800 },
801 {
802 name: "multi ref stack",
803 stack: Stack{
804 Refs: map[string]StackRef{
805 "abc": {SHA: "abc", Prev: "", Next: "def"},
806 "def": {SHA: "def", Prev: "abc", Next: ""},
807 },
808 },
809 expectedIterations: 2,
810 },
811 }
813 for _, tt := range tests {
814 t.Run(tt.name, func(t *testing.T) {
815 items := slices.Collect(tt.stack.Iter())
817 assert.Len(t, items, tt.expectedIterations)
818 })
819 }
822func TestStack_Iter2(t *testing.T) {
823 type result struct {
824 index int
825 ref StackRef
826 }
827 tests := []struct {
828 name string
829 stack Stack
830 expected []result
831 }{
832 {
833 name: "Empty stack",
834 stack: Stack{
835 Refs: map[string]StackRef{},
836 },
837 expected: []result{},
838 },
839 {
840 name: "Stack with multiple refs",
841 stack: Stack{
842 Refs: map[string]StackRef{
843 "sha1": {SHA: "sha1", Branch: "branch1", Prev: "", Next: "sha2"},
844 "sha2": {SHA: "sha2", Branch: "branch2", Prev: "sha1", Next: "sha3"},
845 "sha3": {SHA: "sha3", Branch: "branch3", Prev: "sha2", Next: ""},
846 },
847 },
848 expected: []result{
849 {0, StackRef{SHA: "sha1", Branch: "branch1", Next: "sha2"}},
850 {1, StackRef{SHA: "sha2", Branch: "branch2", Prev: "sha1", Next: "sha3"}},
851 {2, StackRef{SHA: "sha3", Branch: "branch3", Prev: "sha2"}},
852 },
853 },
854 {
855 name: "Stack with 1 ref",
856 stack: Stack{
857 Refs: map[string]StackRef{
858 "sha1": {SHA: "sha1", Branch: "branch1", Prev: "", Next: ""},
859 },
860 },
861 expected: []result{
862 {0, StackRef{SHA: "sha1", Branch: "branch1", Next: ""}},
863 },
864 },
865 }
867 for _, tt := range tests {
868 t.Run(tt.name, func(t *testing.T) {
869 results := []result{}
871 for i, v := range tt.stack.Iter2() {
872 assert.Equal(t, i, tt.expected[i].index)
873 assert.Equal(t, v, tt.expected[i].ref)
874 results = append(results, result{i, v})
875 }
877 assert.Equal(t, tt.expected, results)
878 })
879 }
882func Test_StackRefSubject(t *testing.T) {
883 tests := []struct {
884 name string
885 description string
886 expected string
887 }{
888 {
889 name: "single line",
890 description: "simple title",
891 expected: "simple title",
892 },
893 {
894 name: "multi-line with body",
895 description: "commit subject\n\ncommit body with details",
896 expected: "commit subject",
897 },
898 {
899 name: "multi-line with trailer",
900 description: "commit subject\n\nChangelog: changed",
901 expected: "commit subject",
902 },
903 {
904 name: "long subject truncated",
905 description: "this is a very long subject line that exceeds the seventy two character limit for display",
906 expected: "this is a very long subject line that exceeds the seventy two charact...",
907 },
908 {
909 name: "empty description",
910 description: "",
911 expected: "",
912 },
913 }
915 for _, tt := range tests {
916 t.Run(tt.name, func(t *testing.T) {
917 ref := StackRef{Description: tt.description}
918 assert.Equal(t, tt.expected, ref.Subject())
919 })
920 }
923func Test_StackRefBody(t *testing.T) {
924 tests := []struct {
925 name string
926 description string
927 expected string
928 }{
929 {
930 name: "single line no body",
931 description: "simple title",
932 expected: "",
933 },
934 {
935 name: "multi-line with body",
936 description: "commit subject\n\ncommit body with details",
937 expected: "commit body with details",
938 },
939 {
940 name: "multi-line with trailer",
941 description: "commit subject\n\nChangelog: changed",
942 expected: "Changelog: changed",
943 },
944 {
945 name: "body with multiple lines",
946 description: "subject\n\nline one\nline two\nline three",
947 expected: "line one\nline two\nline three",
948 },
949 {
950 name: "empty description",
951 description: "",
952 expected: "",
953 },
954 }
956 for _, tt := range tests {
957 t.Run(tt.name, func(t *testing.T) {
958 ref := StackRef{Description: tt.description}
959 assert.Equal(t, tt.expected, ref.Body())
960 })
961 }
Diagnostics6 git calls · 42 ms
CallStatusSizeTime042 ms
discover200185 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
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
fetchtree:0 · deepen 1020032 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=4
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0200510 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=510
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=a3147172443266d011121808a125248c5c915972
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=510
git.pkt.payload.max=483
git.sideband.band1.bytes=483
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=483
git.pack.trailer=4ef234d86a93490a6a3da3549aa13a474a5c9eac
Open pack map
fetch2003.5 KiB · hit32 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=31
git.response.bytes=3631
git.response.cache=HIT
git.response.duration_ms=32
git.fetch.wants=a0e8c4562a382fdb13d3c8c632ce17bbaf296ccc
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=3631
git.pkt.payload.max=3604
git.sideband.band1.bytes=3604
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
a5e11ec4dbcb7fd8
Request
ef88dcce…
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