GitLabgitlab-org

cli

main
ply8 git calls261 ms104 KiB5 cachedprotocol v2
1583 lines49 KiBRaw
1//go:build !integration
3package sync
5import (
6 "bytes"
7 "errors"
8 "fmt"
9 "io"
10 "net/http"
11 "os"
12 "path/filepath"
13 "strings"
14 "testing"
16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
18 "go.uber.org/mock/gomock"
20 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
21 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
23 "gitlab.com/gitlab-org/cli/internal/api"
24 "gitlab.com/gitlab-org/cli/internal/cmdutils"
25 "gitlab.com/gitlab-org/cli/internal/git"
26 git_testing "gitlab.com/gitlab-org/cli/internal/git/testing"
27 "gitlab.com/gitlab-org/cli/internal/glrepo"
28 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
31type SyncScenario struct {
32 refs map[string]TestRef
33 title string
34 baseBranch string
35 pushNeeded bool
36 pushErr error
37 noVerify bool
38 skipPush bool
39 updateBase bool
40 rebaseError bool
41 skipMRCreation bool
42 assignees []string
43 labels []string
44 reviewers []string
45 template string
46 templateContents string
47 wantSkippedBranches []string
50type TestRef struct {
51 ref git.StackRef
52 state string
55func setupTestFactory(t *testing.T, testClient *gitlabtesting.TestClient) (cmdutils.Factory, *options) {
56 t.Helper()
58 ios, _, _, _ := cmdtest.TestIOStreams()
60 // Create api.Client that wraps the mock gitlab.Client
61 apiClient, err := api.NewClient(
62 func(*http.Client) (gitlab.AuthSource, error) {
63 return gitlab.AccessTokenAuthSource{Token: ""}, nil
64 },
65 api.WithGitLabClient(testClient.Client),
66 )
67 require.NoError(t, err)
69 f := cmdtest.NewTestFactory(ios,
70 cmdtest.WithGitLabClient(testClient.Client),
71 func(f *cmdtest.Factory) {
72 f.BaseRepoStub = func() (glrepo.Interface, error) {
73 return glrepo.TestProject("stack_guy", "stackproject"), nil
74 }
75 f.ApiClientStub = func(repoHost string) (*api.Client, error) {
76 return apiClient, nil
77 }
78 },
79 func(f *cmdtest.Factory) {
80 f.RemotesStub = func() (glrepo.Remotes, error) {
81 r := glrepo.Remotes{
82 &glrepo.Remote{
83 Remote: &git.Remote{
84 Name: "origin",
85 Resolved: "head: gitlab.com/stack_guy/stackproject",
86 },
87 Repo: glrepo.TestProject("stack_guy", "stackproject"),
88 },
89 }
90 return r, nil
91 }
92 },
93 )
95 client, _ := f.GitLabClient()
97 return f, &options{
98 io: ios,
99 remotes: f.Remotes,
100 labClient: client,
101 baseRepo: f.BaseRepo,
102 }
105func TestNewCmdSyncStack_Flags(t *testing.T) {
106 t.Parallel()
107 ios, _, _, _ := cmdtest.TestIOStreams()
108 f := cmdtest.NewTestFactory(ios)
109 var gr git.StandardGitCommand
111 cmd := NewCmdSyncStack(f, gr)
113 // Test --no-verify flag exists
114 noVerifyFlag := cmd.Flag("no-verify")
115 require.NotNil(t, noVerifyFlag)
116 assert.Equal(t, "false", noVerifyFlag.DefValue)
117 assert.Contains(t, noVerifyFlag.Usage, "pre-push hook")
119 // Test --update-base flag exists
120 updateBaseFlag := cmd.Flag("update-base")
121 require.NotNil(t, updateBaseFlag)
122 assert.Equal(t, "false", updateBaseFlag.DefValue)
123 assert.Contains(t, updateBaseFlag.Usage, "base branch")
125 // Test --skip-mr-creation flag exists
126 skipMRCreationFlag := cmd.Flag("skip-mr-creation")
127 require.NotNil(t, skipMRCreationFlag)
128 assert.Equal(t, "false", skipMRCreationFlag.DefValue)
129 assert.Contains(t, skipMRCreationFlag.Usage, "merge requests")
131 // Test --assignee flag exists
132 assigneeFlag := cmd.Flag("assignee")
133 require.NotNil(t, assigneeFlag)
134 assert.Equal(t, "[]", assigneeFlag.DefValue)
135 assert.Equal(t, "a", assigneeFlag.Shorthand)
136 assert.Contains(t, assigneeFlag.Usage, "usernames")
138 // Test --label flag exists
139 labelFlag := cmd.Flag("label")
140 require.NotNil(t, labelFlag)
141 assert.Equal(t, "[]", labelFlag.DefValue)
142 assert.Equal(t, "l", labelFlag.Shorthand)
143 assert.Contains(t, labelFlag.Usage, "name")
145 // Test --reviewer flag exists
146 reviewerFlag := cmd.Flag("reviewer")
147 require.NotNil(t, reviewerFlag)
148 assert.Equal(t, "[]", reviewerFlag.DefValue)
149 assert.Contains(t, reviewerFlag.Usage, "usernames")
151 // Test --skip-push flag exists
152 skipPushFlag := cmd.Flag("skip-push")
153 require.NotNil(t, skipPushFlag)
154 assert.Equal(t, "false", skipPushFlag.DefValue)
155 assert.Contains(t, skipPushFlag.Usage, "pushing")
158func TestNewCmdSyncStack_MissingTemplate(t *testing.T) {
159 git.InitGitRepoWithCommit(t)
160 ios, _, _, _ := cmdtest.TestIOStreams()
161 cmd := NewCmdSyncStack(cmdtest.NewTestFactory(ios), git.StandardGitCommand{})
162 cmd.SetArgs([]string{"--template", "missing"})
164 require.ErrorContains(t, cmd.Execute(), `template "missing" not found`)
167func Test_stackSync(t *testing.T) {
168 type args struct {
169 stack SyncScenario
170 }
172 forcePushErr := errors.New("pre-push hook rejected force push")
174 twoNewBranches := func(template, templateContents string) args {
175 return args{stack: SyncScenario{
176 title: "my cool stack",
177 template: template,
178 templateContents: templateContents,
179 refs: map[string]TestRef{
180 "1": {
181 ref: git.StackRef{SHA: "1", Next: "2", Branch: "Branch1", Description: "first branch\n\nFirst diff details"},
182 state: NothingToCommit,
183 },
184 "2": {
185 ref: git.StackRef{SHA: "2", Prev: "1", Branch: "Branch2", Description: "second branch"},
186 state: NothingToCommit,
187 },
188 },
189 }}
190 }
191 mockTwoNewMergeRequests := func(firstDescription, secondDescription string) func(*testing.T, *gitlabtesting.TestClient) {
192 return func(t *testing.T, testClient *gitlabtesting.TestClient) {
193 t.Helper()
194 testClient.MockUsers.EXPECT().CurrentUser(gomock.Any()).Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
196 requests := []gitlab.BasicMergeRequest{
197 {IID: 43, SourceBranch: "Branch1", TargetBranch: "main", Title: "first branch", Description: firstDescription},
198 {IID: 44, SourceBranch: "Branch2", TargetBranch: "Branch1", Title: "second branch", Description: secondDescription},
199 }
200 for _, want := range requests {
201 testClient.MockMergeRequests.EXPECT().CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
202 DoAndReturn(func(_ any, opts *gitlab.CreateMergeRequestOptions, _ ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
203 require.Equal(t, want.SourceBranch, *opts.SourceBranch)
204 require.Equal(t, want.TargetBranch, *opts.TargetBranch)
205 require.Equal(t, want.Title, *opts.Title)
206 require.Equal(t, want.Description, *opts.Description)
207 return &gitlab.MergeRequest{BasicMergeRequest: want}, nil, nil
208 })
209 }
210 }
211 }
213 mockCurrentUser := func(t *testing.T, client *gitlabtesting.TestClient) {
214 t.Helper()
215 client.MockUsers.EXPECT().CurrentUser(gomock.Any()).
216 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
217 }
218 skipMRCreationArgs := func(template string) args {
219 return args{
220 stack: SyncScenario{
221 title: "skip mr stack",
222 skipMRCreation: true,
223 template: template,
224 refs: map[string]TestRef{
225 "1": {
226 ref: git.StackRef{SHA: "1", Prev: "", Next: "2", Branch: "Branch1", MR: "", Description: "first branch"},
227 state: NothingToCommit,
228 },
229 "2": {
230 ref: git.StackRef{SHA: "2", Prev: "1", Next: "", Branch: "Branch2", MR: "", Description: "second branch"},
231 state: NothingToCommit,
232 },
233 },
234 },
235 }
236 }
238 skipPushArgs := func(template string) args {
239 return args{
240 stack: SyncScenario{
241 title: "skip push no mr",
242 skipPush: true,
243 template: template,
244 refs: map[string]TestRef{
245 "1": {
246 ref: git.StackRef{
247 SHA: "1",
248 Prev: "",
249 Next: "",
250 Branch: "Branch1",
251 MR: "",
252 Description: "test branch",
253 },
254 state: NothingToCommit,
255 },
256 },
257 },
258 }
259 }
261 tests := []struct {
262 name string
263 args args
264 setupMocks func(t *testing.T, testClient *gitlabtesting.TestClient)
265 wantErr bool
266 wantErrMsg string
267 wantErrIs error
268 wantTemplateWarning bool
269 }{
270 {
271 name: "two branches, 1st branch has MR, 2nd branch behind, stacks are named",
272 args: args{
273 stack: SyncScenario{
274 title: "my cool stack",
275 refs: map[string]TestRef{
276 "1": {
277 ref: git.StackRef{
278 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
279 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
280 Description: "single line desc",
281 },
282 state: NothingToCommit,
283 },
284 "2": {
285 ref: git.StackRef{SHA: "2", Prev: "1", Next: "", Branch: "Branch2", MR: "", Description: "multi line desc\n\ndescription, bark!"},
286 state: BranchIsBehind,
287 },
288 },
289 },
290 },
291 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
292 t.Helper()
293 // MockStackUser
294 testClient.MockUsers.EXPECT().
295 CurrentUser(gomock.Any()).
296 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
298 testClient.MockMergeRequests.EXPECT().
299 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
300 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
301 assert.Equal(t, "Branch1", *opts.SourceBranch)
302 return []*gitlab.BasicMergeRequest{
303 {
304 ID: 25,
305 IID: 25,
306 ProjectID: 3,
307 Title: "test mr title",
308 TargetBranch: "main",
309 SourceBranch: "Branch1",
310 State: "opened",
311 Description: "test mr description25",
312 Author: &gitlab.BasicUser{ID: 1, Username: "admin"},
313 },
314 }, nil, nil
315 })
317 testClient.MockMergeRequests.EXPECT().
318 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
319 Return(&gitlab.MergeRequest{
320 BasicMergeRequest: gitlab.BasicMergeRequest{
321 ID: 25,
322 IID: 25,
323 ProjectID: 3,
324 Title: "test mr title",
325 TargetBranch: "main",
326 SourceBranch: "Branch1",
327 State: "opened",
328 Description: "test mr description25",
329 Author: &gitlab.BasicUser{ID: 1, Username: "admin"},
330 },
331 }, nil, nil)
333 // MockPostStackMR(Source: "Branch2", Target: "Branch1", Title: "multi line desc", Description: "description, bark!")
334 testClient.MockMergeRequests.EXPECT().
335 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
336 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
337 assert.Equal(t, "Branch2", *opts.SourceBranch)
338 assert.Equal(t, "Branch1", *opts.TargetBranch)
339 assert.Equal(t, "multi line desc", *opts.Title)
340 assert.Equal(t, "description, bark!", *opts.Description)
341 return &gitlab.MergeRequest{
342 BasicMergeRequest: gitlab.BasicMergeRequest{
343 IID: 42,
344 SourceBranch: "Branch2",
345 TargetBranch: "Branch1",
346 Title: "multi line desc",
347 Description: "description, bark!",
348 },
349 }, nil, nil
350 })
351 },
352 },
354 {
355 name: "two branches, no MRs, nothing to commit",
356 args: twoNewBranches("", ""),
357 setupMocks: mockTwoNewMergeRequests("First diff details", ""),
358 },
359 {
360 name: "two new merge requests use the template and preserve their commit message bodies",
361 args: twoNewBranches("Review", "## Review\n"),
362 setupMocks: mockTwoNewMergeRequests("## Review\n\nFirst diff details", "## Review"),
363 },
365 {
366 name: "a complicated scenario",
367 args: args{
368 stack: SyncScenario{
369 title: "my cool stack",
370 pushNeeded: true,
371 refs: map[string]TestRef{
372 "1": {
373 ref: git.StackRef{
374 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
375 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
376 },
377 state: NothingToCommit,
378 },
379 "2": {
380 ref: git.StackRef{SHA: "2", Prev: "1", Next: "3", Branch: "Branch2", MR: ""},
381 state: NothingToCommit,
382 },
383 "3": {
384 ref: git.StackRef{SHA: "3", Prev: "2", Next: "4", Branch: "Branch3", MR: ""},
385 state: NothingToCommit,
386 },
387 "4": {
388 ref: git.StackRef{SHA: "4", Prev: "3", Next: "5", Branch: "Branch4", MR: ""},
389 state: BranchHasDiverged,
390 },
391 "5": {
392 ref: git.StackRef{SHA: "5", Prev: "4", Next: "6", Branch: "Branch5", MR: ""},
393 state: NothingToCommit,
394 },
395 "6": {
396 ref: git.StackRef{SHA: "6", Prev: "5", Next: "", Branch: "Branch6", MR: ""},
397 state: NothingToCommit,
398 },
399 },
400 },
401 },
402 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
403 t.Helper()
404 // MockStackUser
405 testClient.MockUsers.EXPECT().
406 CurrentUser(gomock.Any()).
407 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
409 testClient.MockMergeRequests.EXPECT().
410 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
411 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
412 assert.Equal(t, "Branch1", *opts.SourceBranch)
413 return []*gitlab.BasicMergeRequest{
414 {
415 ID: 25,
416 IID: 25,
417 ProjectID: 3,
418 SourceBranch: "Branch1",
419 State: "opened",
420 },
421 }, nil, nil
422 })
424 testClient.MockMergeRequests.EXPECT().
425 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
426 Return(&gitlab.MergeRequest{
427 BasicMergeRequest: gitlab.BasicMergeRequest{
428 ID: 25,
429 IID: 25,
430 ProjectID: 3,
431 SourceBranch: "Branch1",
432 State: "opened",
433 },
434 }, nil, nil)
436 // Create MRs for Branch2-6
437 for i := 2; i <= 6; i++ {
438 testClient.MockMergeRequests.EXPECT().
439 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
440 Return(&gitlab.MergeRequest{
441 BasicMergeRequest: gitlab.BasicMergeRequest{
442 IID: int64(40 + i),
443 },
444 }, nil, nil)
445 }
446 },
447 },
448 {
449 name: "non standard base branch",
450 args: args{
451 stack: SyncScenario{
452 title: "my cool stack",
453 baseBranch: "jawn",
454 refs: map[string]TestRef{
455 "1": {
456 ref: git.StackRef{SHA: "1", Prev: "", Next: "2", Branch: "Branch1", MR: ""},
457 state: BranchIsBehind,
458 },
459 "2": {
460 ref: git.StackRef{SHA: "2", Prev: "1", Next: "", Branch: "Branch2", MR: ""},
461 state: BranchIsBehind,
462 },
463 },
464 },
465 },
466 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
467 t.Helper()
468 // MockStackUser
469 testClient.MockUsers.EXPECT().
470 CurrentUser(gomock.Any()).
471 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
473 // MockPostStackMR(Source: "Branch1", Target: "jawn")
474 testClient.MockMergeRequests.EXPECT().
475 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
476 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
477 assert.Equal(t, "Branch1", *opts.SourceBranch)
478 assert.Equal(t, "jawn", *opts.TargetBranch)
479 return &gitlab.MergeRequest{
480 BasicMergeRequest: gitlab.BasicMergeRequest{
481 IID: 45,
482 SourceBranch: "Branch1",
483 TargetBranch: "jawn",
484 },
485 }, nil, nil
486 })
488 // MockPostStackMR(Source: "Branch2", Target: "Branch1")
489 testClient.MockMergeRequests.EXPECT().
490 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
491 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
492 assert.Equal(t, "Branch2", *opts.SourceBranch)
493 assert.Equal(t, "Branch1", *opts.TargetBranch)
494 return &gitlab.MergeRequest{
495 BasicMergeRequest: gitlab.BasicMergeRequest{
496 IID: 46,
497 SourceBranch: "Branch2",
498 TargetBranch: "Branch1",
499 },
500 }, nil, nil
501 })
502 },
503 },
505 {
506 name: "no-verify flag is passed to git push",
507 args: args{
508 stack: SyncScenario{
509 title: "my cool stack",
510 noVerify: true,
511 refs: map[string]TestRef{
512 "1": {
513 ref: git.StackRef{SHA: "1", Prev: "", Next: "2", Branch: "Branch1", MR: "", Description: "first branch"},
514 state: NothingToCommit,
515 },
516 "2": {
517 ref: git.StackRef{SHA: "2", Prev: "1", Next: "", Branch: "Branch2", MR: "", Description: "second branch"},
518 state: NothingToCommit,
519 },
520 },
521 },
522 },
523 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
524 t.Helper()
525 // MockStackUser
526 testClient.MockUsers.EXPECT().
527 CurrentUser(gomock.Any()).
528 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
530 // MockPostStackMR(Source: "Branch1", Target: "main", Title: "first branch")
531 testClient.MockMergeRequests.EXPECT().
532 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
533 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
534 assert.Equal(t, "Branch1", *opts.SourceBranch)
535 assert.Equal(t, "main", *opts.TargetBranch)
536 assert.Equal(t, "first branch", *opts.Title)
537 return &gitlab.MergeRequest{
538 BasicMergeRequest: gitlab.BasicMergeRequest{
539 IID: 47,
540 SourceBranch: "Branch1",
541 TargetBranch: "main",
542 Title: "first branch",
543 },
544 }, nil, nil
545 })
547 // MockPostStackMR(Source: "Branch2", Target: "Branch1", Title: "second branch")
548 testClient.MockMergeRequests.EXPECT().
549 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
550 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
551 assert.Equal(t, "Branch2", *opts.SourceBranch)
552 assert.Equal(t, "Branch1", *opts.TargetBranch)
553 assert.Equal(t, "second branch", *opts.Title)
554 return &gitlab.MergeRequest{
555 BasicMergeRequest: gitlab.BasicMergeRequest{
556 IID: 48,
557 SourceBranch: "Branch2",
558 TargetBranch: "Branch1",
559 Title: "second branch",
560 },
561 }, nil, nil
562 })
563 },
564 },
566 {
567 name: "no-verify flag with force push",
568 args: args{
569 stack: SyncScenario{
570 title: "my cool stack",
571 noVerify: true,
572 pushNeeded: true,
573 refs: map[string]TestRef{
574 "1": {
575 ref: git.StackRef{
576 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
577 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
578 },
579 state: NothingToCommit,
580 },
581 "2": {
582 ref: git.StackRef{SHA: "2", Prev: "1", Next: "", Branch: "Branch2", MR: ""},
583 state: BranchHasDiverged,
584 },
585 },
586 },
587 },
588 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
589 t.Helper()
590 // MockStackUser
591 testClient.MockUsers.EXPECT().
592 CurrentUser(gomock.Any()).
593 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
595 testClient.MockMergeRequests.EXPECT().
596 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
597 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
598 assert.Equal(t, "Branch1", *opts.SourceBranch)
599 return []*gitlab.BasicMergeRequest{
600 {
601 ID: 25,
602 IID: 25,
603 ProjectID: 3,
604 Title: "test mr title",
605 TargetBranch: "main",
606 SourceBranch: "Branch1",
607 State: "opened",
608 Description: "test mr description25",
609 Author: &gitlab.BasicUser{ID: 1, Username: "admin"},
610 },
611 }, nil, nil
612 })
614 testClient.MockMergeRequests.EXPECT().
615 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
616 Return(&gitlab.MergeRequest{
617 BasicMergeRequest: gitlab.BasicMergeRequest{
618 ID: 25,
619 IID: 25,
620 ProjectID: 3,
621 Title: "test mr title",
622 TargetBranch: "main",
623 SourceBranch: "Branch1",
624 State: "opened",
625 Description: "test mr description25",
626 Author: &gitlab.BasicUser{ID: 1, Username: "admin"},
627 },
628 }, nil, nil)
630 // MockPostStackMR(Source: "Branch2", Target: "Branch1")
631 testClient.MockMergeRequests.EXPECT().
632 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
633 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
634 assert.Equal(t, "Branch2", *opts.SourceBranch)
635 assert.Equal(t, "Branch1", *opts.TargetBranch)
636 return &gitlab.MergeRequest{
637 BasicMergeRequest: gitlab.BasicMergeRequest{
638 IID: 49,
639 SourceBranch: "Branch2",
640 TargetBranch: "Branch1",
641 },
642 }, nil, nil
643 })
644 },
645 },
647 {
648 name: "update-base rebases stack onto base branch with diverged branches",
649 args: args{
650 stack: SyncScenario{
651 title: "my cool stack",
652 updateBase: true,
653 pushNeeded: true,
654 refs: map[string]TestRef{
655 "1": {
656 ref: git.StackRef{
657 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
658 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
659 },
660 state: BranchHasDiverged,
661 },
662 "2": {
663 ref: git.StackRef{
664 SHA: "2", Prev: "1", Next: "", Branch: "Branch2",
665 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
666 },
667 state: BranchHasDiverged,
668 },
669 },
670 },
671 },
672 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
673 t.Helper()
674 testClient.MockUsers.EXPECT().
675 CurrentUser(gomock.Any()).
676 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
678 testClient.MockMergeRequests.EXPECT().
679 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
680 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
681 return []*gitlab.BasicMergeRequest{
682 {
683 ID: 25,
684 IID: 25,
685 ProjectID: 3,
686 SourceBranch: *opts.SourceBranch,
687 State: "opened",
688 },
689 }, nil, nil
690 }).Times(2)
692 testClient.MockMergeRequests.EXPECT().
693 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
694 Return(&gitlab.MergeRequest{
695 BasicMergeRequest: gitlab.BasicMergeRequest{
696 ID: 25,
697 IID: 25,
698 ProjectID: 3,
699 State: "opened",
700 },
701 }, nil, nil).Times(2)
702 },
703 },
705 {
706 name: "update-base with custom base branch",
707 args: args{
708 stack: SyncScenario{
709 title: "my cool stack",
710 baseBranch: "develop",
711 updateBase: true,
712 pushNeeded: true,
713 refs: map[string]TestRef{
714 "1": {
715 ref: git.StackRef{
716 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
717 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
718 },
719 state: BranchHasDiverged,
720 },
721 "2": {
722 ref: git.StackRef{
723 SHA: "2", Prev: "1", Next: "", Branch: "Branch2",
724 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
725 },
726 state: BranchHasDiverged,
727 },
728 },
729 },
730 },
731 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
732 t.Helper()
733 testClient.MockUsers.EXPECT().
734 CurrentUser(gomock.Any()).
735 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
737 testClient.MockMergeRequests.EXPECT().
738 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
739 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
740 return []*gitlab.BasicMergeRequest{
741 {
742 ID: 25,
743 IID: 25,
744 ProjectID: 3,
745 SourceBranch: *opts.SourceBranch,
746 State: "opened",
747 },
748 }, nil, nil
749 }).Times(2)
751 testClient.MockMergeRequests.EXPECT().
752 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
753 Return(&gitlab.MergeRequest{
754 BasicMergeRequest: gitlab.BasicMergeRequest{
755 ID: 25,
756 IID: 25,
757 ProjectID: 3,
758 State: "opened",
759 },
760 }, nil, nil).Times(2)
761 },
762 },
764 {
765 name: "failed force-push hook preserves wrapped error",
766 args: args{
767 stack: SyncScenario{
768 title: "force push failure",
769 updateBase: true,
770 pushNeeded: true,
771 pushErr: forcePushErr,
772 refs: map[string]TestRef{
773 "1": {
774 ref: git.StackRef{
775 SHA: "1",
776 Branch: "Branch1",
777 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/25",
778 },
779 state: NothingToCommit,
780 },
781 },
782 },
783 },
784 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
785 t.Helper()
786 testClient.MockUsers.EXPECT().
787 CurrentUser(gomock.Any()).
788 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
789 testClient.MockMergeRequests.EXPECT().
790 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
791 Return([]*gitlab.BasicMergeRequest{
792 {
793 ID: 25,
794 IID: 25,
795 ProjectID: 3,
796 SourceBranch: "Branch1",
797 State: "opened",
798 },
799 }, nil, nil)
800 testClient.MockMergeRequests.EXPECT().
801 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
802 Return(&gitlab.MergeRequest{
803 BasicMergeRequest: gitlab.BasicMergeRequest{
804 ID: 25,
805 IID: 25,
806 ProjectID: 3,
807 SourceBranch: "Branch1",
808 State: "opened",
809 },
810 }, nil, nil)
811 },
812 wantErr: true,
813 wantErrMsg: "error pushing branches to remote",
814 wantErrIs: forcePushErr,
815 },
817 {
818 name: "update-base rebase failure includes target branch name in error",
819 args: args{
820 stack: SyncScenario{
821 title: "my cool stack",
822 updateBase: true,
823 rebaseError: true,
824 baseBranch: "feature-branch",
825 refs: map[string]TestRef{
826 "1": {
827 ref: git.StackRef{
828 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
829 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
830 },
831 state: NothingToCommit,
832 },
833 "2": {
834 ref: git.StackRef{
835 SHA: "2", Prev: "1", Next: "", Branch: "Branch2",
836 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
837 },
838 state: NothingToCommit,
839 },
840 },
841 },
842 },
843 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
844 t.Helper()
845 testClient.MockUsers.EXPECT().
846 CurrentUser(gomock.Any()).
847 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
848 },
849 wantErr: true,
850 wantErrMsg: "could not rebase onto origin/feature-branch",
851 },
853 {
854 name: "single branch with custom assignees",
855 args: args{
856 stack: SyncScenario{
857 title: "assignee stack",
858 assignees: []string{"reviewer1", "reviewer2"},
859 refs: map[string]TestRef{
860 "1": {
861 ref: git.StackRef{SHA: "1", Prev: "", Next: "", Branch: "Branch1", MR: "", Description: "test MR"},
862 state: NothingToCommit,
863 },
864 },
865 },
866 },
867 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
868 t.Helper()
869 testClient.MockUsers.EXPECT().
870 CurrentUser(gomock.Any()).
871 Return(&gitlab.User{Username: "stack_guy", ID: 100}, nil, nil)
873 testClient.MockUsers.EXPECT().
874 ListUsers(gomock.Any()).
875 Return([]*gitlab.User{{ID: 201, Username: "reviewer1"}}, nil, nil)
876 testClient.MockUsers.EXPECT().
877 ListUsers(gomock.Any()).
878 Return([]*gitlab.User{{ID: 202, Username: "reviewer2"}}, nil, nil)
880 testClient.MockMergeRequests.EXPECT().
881 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
882 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
883 assert.Equal(t, "Branch1", *opts.SourceBranch)
884 assert.Equal(t, "main", *opts.TargetBranch)
885 assert.Equal(t, "test MR", *opts.Title)
886 assert.NotNil(t, opts.AssigneeIDs)
887 assert.ElementsMatch(t, []int64{201, 202}, *opts.AssigneeIDs)
888 assert.Nil(t, opts.AssigneeID)
889 return &gitlab.MergeRequest{
890 BasicMergeRequest: gitlab.BasicMergeRequest{
891 IID: 47,
892 SourceBranch: "Branch1",
893 TargetBranch: "main",
894 Title: "test MR",
895 },
896 }, nil, nil
897 })
898 },
899 },
901 {
902 name: "single branch with custom labels",
903 args: args{
904 stack: SyncScenario{
905 title: "label stack",
906 labels: []string{"bug", "priority::high"},
907 refs: map[string]TestRef{
908 "1": {
909 ref: git.StackRef{SHA: "1", Prev: "", Next: "", Branch: "Branch1", MR: "", Description: "test MR with labels"},
910 state: NothingToCommit,
911 },
912 },
913 },
914 },
915 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
916 t.Helper()
917 testClient.MockUsers.EXPECT().
918 CurrentUser(gomock.Any()).
919 Return(&gitlab.User{Username: "stack_guy", ID: 100}, nil, nil)
921 testClient.MockMergeRequests.EXPECT().
922 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
923 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
924 assert.Equal(t, "Branch1", *opts.SourceBranch)
925 assert.Equal(t, "main", *opts.TargetBranch)
926 assert.Equal(t, "test MR with labels", *opts.Title)
927 assert.NotNil(t, opts.Labels)
928 assert.ElementsMatch(t, []string{"bug", "priority::high"}, *opts.Labels)
929 return &gitlab.MergeRequest{
930 BasicMergeRequest: gitlab.BasicMergeRequest{
931 IID: 47,
932 SourceBranch: "Branch1",
933 TargetBranch: "main",
934 Title: "test MR with labels",
935 },
936 }, nil, nil
937 })
938 },
939 },
941 {
942 name: "single branch with custom reviewers",
943 args: args{
944 stack: SyncScenario{
945 title: "reviewer stack",
946 reviewers: []string{"reviewer1", "reviewer2"},
947 refs: map[string]TestRef{
948 "1": {
949 ref: git.StackRef{SHA: "1", Prev: "", Next: "", Branch: "Branch1", MR: "", Description: "test MR with reviewers"},
950 state: NothingToCommit,
951 },
952 },
953 },
954 },
955 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
956 t.Helper()
957 testClient.MockUsers.EXPECT().
958 CurrentUser(gomock.Any()).
959 Return(&gitlab.User{Username: "stack_guy", ID: 100}, nil, nil)
961 testClient.MockUsers.EXPECT().
962 ListUsers(gomock.Any()).
963 Return([]*gitlab.User{{ID: 201, Username: "reviewer1"}}, nil, nil)
964 testClient.MockUsers.EXPECT().
965 ListUsers(gomock.Any()).
966 Return([]*gitlab.User{{ID: 202, Username: "reviewer2"}}, nil, nil)
968 testClient.MockMergeRequests.EXPECT().
969 CreateMergeRequest("stack_guy/stackproject", gomock.Any()).
970 DoAndReturn(func(pid any, opts *gitlab.CreateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
971 assert.Equal(t, "Branch1", *opts.SourceBranch)
972 assert.Equal(t, "main", *opts.TargetBranch)
973 assert.Equal(t, "test MR with reviewers", *opts.Title)
974 assert.NotNil(t, opts.ReviewerIDs)
975 assert.ElementsMatch(t, []int64{201, 202}, *opts.ReviewerIDs)
976 return &gitlab.MergeRequest{
977 BasicMergeRequest: gitlab.BasicMergeRequest{
978 IID: 47,
979 SourceBranch: "Branch1",
980 TargetBranch: "main",
981 Title: "test MR with reviewers",
982 },
983 }, nil, nil
984 })
985 },
986 },
988 {
989 name: "skip-mr-creation skips MR creation for branches without MRs",
990 args: skipMRCreationArgs(""),
991 setupMocks: mockCurrentUser,
992 },
993 {
994 name: "skip-mr-creation warns and ignores a missing template for branches without MRs",
995 args: skipMRCreationArgs("missing"),
996 setupMocks: mockCurrentUser,
997 wantTemplateWarning: true,
998 },
1001 name: "skip-mr-creation still checks existing MRs",
1002 args: args{
1003 stack: SyncScenario{
1004 title: "skip mr with existing",
1005 skipMRCreation: true,
1006 refs: map[string]TestRef{
1007 "1": {
1008 ref: git.StackRef{
1009 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
1010 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
1011 Description: "has MR",
1012 },
1013 state: NothingToCommit,
1014 },
1015 "2": {
1016 ref: git.StackRef{SHA: "2", Prev: "1", Next: "", Branch: "Branch2", MR: "", Description: "no MR"},
1017 state: NothingToCommit,
1018 },
1019 },
1020 },
1021 },
1022 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
1023 t.Helper()
1024 testClient.MockUsers.EXPECT().
1025 CurrentUser(gomock.Any()).
1026 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
1028 testClient.MockMergeRequests.EXPECT().
1029 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
1030 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
1031 assert.Equal(t, "Branch1", *opts.SourceBranch)
1032 return []*gitlab.BasicMergeRequest{
1034 ID: 25,
1035 IID: 25,
1036 ProjectID: 3,
1037 SourceBranch: "Branch1",
1038 State: "opened",
1039 },
1040 }, nil, nil
1041 })
1043 testClient.MockMergeRequests.EXPECT().
1044 GetMergeRequest("stack_guy/stackproject", int64(25), gomock.Any()).
1045 Return(&gitlab.MergeRequest{
1046 BasicMergeRequest: gitlab.BasicMergeRequest{
1047 ID: 25,
1048 IID: 25,
1049 ProjectID: 3,
1050 State: "opened",
1051 },
1052 }, nil, nil)
1053 },
1054 },
1057 name: "skip-push rebases diverged stack without pushing",
1058 args: args{
1059 stack: SyncScenario{
1060 title: "skip push cascade",
1061 skipPush: true,
1062 pushNeeded: true,
1063 refs: map[string]TestRef{
1064 "1": {
1065 ref: git.StackRef{
1066 SHA: "1",
1067 Prev: "",
1068 Next: "2",
1069 Branch: "Branch1",
1070 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
1071 },
1072 state: NothingToCommit,
1073 },
1074 "2": {
1075 ref: git.StackRef{
1076 SHA: "2",
1077 Prev: "1",
1078 Next: "",
1079 Branch: "Branch2",
1080 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
1081 },
1082 state: BranchHasDiverged,
1083 },
1084 },
1085 },
1086 },
1087 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
1088 t.Helper()
1090 testClient.MockUsers.EXPECT().
1091 CurrentUser(gomock.Any()).
1092 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
1094 testClient.MockMergeRequests.EXPECT().
1095 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
1096 DoAndReturn(func(
1097 pid any,
1098 opts *gitlab.ListProjectMergeRequestsOptions,
1099 options ...gitlab.RequestOptionFunc,
1100 ) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
1101 return []*gitlab.BasicMergeRequest{
1103 ID: 25,
1104 IID: 25,
1105 ProjectID: 3,
1106 SourceBranch: *opts.SourceBranch,
1107 State: "opened",
1108 },
1109 }, nil, nil
1110 }).Times(2)
1112 testClient.MockMergeRequests.EXPECT().
1113 GetMergeRequest("stack_guy/stackproject", gomock.Any(), gomock.Any()).
1114 Return(&gitlab.MergeRequest{
1115 BasicMergeRequest: gitlab.BasicMergeRequest{
1116 ID: 25,
1117 IID: 25,
1118 State: "opened",
1119 },
1120 }, nil, nil).Times(2)
1121 },
1122 },
1125 name: "skip-push skips MR creation for branches without MRs",
1126 args: skipPushArgs(""),
1127 setupMocks: mockCurrentUser,
1128 },
1130 name: "skip-push warns and ignores a missing template for branches without MRs",
1131 args: skipPushArgs("missing"),
1132 setupMocks: mockCurrentUser,
1133 wantTemplateWarning: true,
1134 },
1137 name: "skip-push with update-base rebases all branches without pushing",
1138 args: args{
1139 stack: SyncScenario{
1140 title: "skip push with update base",
1141 skipPush: true,
1142 updateBase: true,
1143 pushNeeded: true,
1144 refs: map[string]TestRef{
1145 "1": {
1146 ref: git.StackRef{
1147 SHA: "1",
1148 Prev: "",
1149 Next: "2",
1150 Branch: "Branch1",
1151 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
1152 },
1153 state: NothingToCommit,
1154 },
1155 "2": {
1156 ref: git.StackRef{
1157 SHA: "2",
1158 Prev: "1",
1159 Next: "",
1160 Branch: "Branch2",
1161 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
1162 },
1163 state: NothingToCommit,
1164 },
1165 },
1166 },
1167 },
1168 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
1169 t.Helper()
1171 testClient.MockUsers.EXPECT().
1172 CurrentUser(gomock.Any()).
1173 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
1175 testClient.MockMergeRequests.EXPECT().
1176 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
1177 DoAndReturn(func(
1178 pid any,
1179 opts *gitlab.ListProjectMergeRequestsOptions,
1180 options ...gitlab.RequestOptionFunc,
1181 ) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
1182 return []*gitlab.BasicMergeRequest{
1184 ID: 25,
1185 IID: 25,
1186 ProjectID: 3,
1187 SourceBranch: *opts.SourceBranch,
1188 State: "opened",
1189 },
1190 }, nil, nil
1191 }).Times(2)
1193 testClient.MockMergeRequests.EXPECT().
1194 GetMergeRequest("stack_guy/stackproject", gomock.Any(), gomock.Any()).
1195 Return(&gitlab.MergeRequest{
1196 BasicMergeRequest: gitlab.BasicMergeRequest{
1197 ID: 25,
1198 IID: 25,
1199 State: "opened",
1200 },
1201 }, nil, nil).Times(2)
1202 },
1203 },
1206 name: "skip-push logs only modified and downstream rebased branches",
1207 args: args{
1208 stack: SyncScenario{
1209 title: "skip push cascade logging",
1210 skipPush: true,
1211 pushNeeded: true,
1212 wantSkippedBranches: []string{"Branch2", "Branch3"},
1213 refs: map[string]TestRef{
1214 "1": {
1215 ref: git.StackRef{
1216 SHA: "1",
1217 Prev: "",
1218 Next: "2",
1219 Branch: "Branch1",
1220 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
1221 },
1222 state: NothingToCommit,
1223 },
1224 "2": {
1225 ref: git.StackRef{
1226 SHA: "2",
1227 Prev: "1",
1228 Next: "3",
1229 Branch: "Branch2",
1230 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
1231 },
1232 state: BranchHasDiverged,
1233 },
1234 "3": {
1235 ref: git.StackRef{
1236 SHA: "3",
1237 Prev: "2",
1238 Next: "",
1239 Branch: "Branch3",
1240 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/3",
1241 },
1242 state: BranchHasDiverged,
1243 },
1244 },
1245 },
1246 },
1247 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
1248 t.Helper()
1250 testClient.MockUsers.EXPECT().
1251 CurrentUser(gomock.Any()).
1252 Return(&gitlab.User{Username: "stack_guy"}, nil, nil)
1254 testClient.MockMergeRequests.EXPECT().
1255 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
1256 DoAndReturn(func(
1257 pid any,
1258 opts *gitlab.ListProjectMergeRequestsOptions,
1259 options ...gitlab.RequestOptionFunc,
1260 ) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
1261 return []*gitlab.BasicMergeRequest{
1263 ID: 25,
1264 IID: 25,
1265 ProjectID: 3,
1266 SourceBranch: *opts.SourceBranch,
1267 State: "opened",
1268 },
1269 }, nil, nil
1270 }).Times(3)
1272 testClient.MockMergeRequests.EXPECT().
1273 GetMergeRequest("stack_guy/stackproject", gomock.Any(), gomock.Any()).
1274 Return(&gitlab.MergeRequest{
1275 BasicMergeRequest: gitlab.BasicMergeRequest{
1276 ID: 25,
1277 IID: 25,
1278 State: "opened",
1279 },
1280 }, nil, nil).Times(3)
1281 },
1282 },
1285 for _, tc := range tests {
1286 t.Run(tc.name, func(t *testing.T) {
1287 git.InitGitRepoWithCommit(t)
1289 testClient := gitlabtesting.NewTestClient(t)
1290 tc.setupMocks(t, testClient)
1292 ctrl := gomock.NewController(t)
1293 mockCmd := git_testing.NewMockGitRunner(ctrl)
1295 f, opts := setupTestFactory(t, testClient)
1297 stdout := &bytes.Buffer{}
1298 stderr := &bytes.Buffer{}
1299 opts.io.StdOut = stdout
1300 opts.io.StdErr = stderr
1302 // Set options from test case
1303 opts.noVerify = tc.args.stack.noVerify
1304 opts.skipPush = tc.args.stack.skipPush
1305 opts.updateBase = tc.args.stack.updateBase
1306 opts.skipMRCreation = tc.args.stack.skipMRCreation
1307 opts.assignees = tc.args.stack.assignees
1308 opts.labels = tc.args.stack.labels
1309 opts.reviewers = tc.args.stack.reviewers
1310 opts.template = tc.args.stack.template
1311 if tc.args.stack.templateContents != "" {
1312 templateDir := filepath.Join(".gitlab", "merge_request_templates")
1313 require.NoError(t, os.MkdirAll(templateDir, 0o755))
1314 require.NoError(t, os.WriteFile(filepath.Join(templateDir, opts.template+".md"), []byte(tc.args.stack.templateContents), 0o600))
1317 err := git.SetCurrentStackTitle(tc.args.stack.title)
1318 require.NoError(t, err)
1320 createStack(t, tc.args.stack.title, tc.args.stack.refs)
1321 stack, err := git.GatherStackRefs(tc.args.stack.title)
1322 require.NoError(t, err)
1324 mockCmd.EXPECT().Git([]string{"fetch", "origin"})
1326 if tc.args.stack.updateBase {
1327 baseBranch := "main"
1328 if tc.args.stack.baseBranch != "" {
1329 baseBranch = tc.args.stack.baseBranch
1330 err := git.AddStackBaseBranch(tc.args.stack.title, tc.args.stack.baseBranch)
1331 require.NoError(t, err)
1332 } else {
1333 mockCmd.EXPECT().Git([]string{"remote", "show", "origin"}).Return("HEAD branch: main", nil)
1336 mockCmd.EXPECT().Git([]string{"checkout", stack.Last().Branch})
1337 if tc.args.stack.rebaseError {
1338 mockCmd.EXPECT().Git([]string{"rebase", "--fork-point", "--update-refs", "origin/" + baseBranch}).
1339 Return("", fmt.Errorf("conflict"))
1340 } else {
1341 mockCmd.EXPECT().Git([]string{"rebase", "--fork-point", "--update-refs", "origin/" + baseBranch})
1345 if !tc.args.stack.rebaseError {
1346 for ref := range stack.Iter() {
1347 state := tc.args.stack.refs[ref.SHA].state
1349 mockCmd.EXPECT().Git([]string{"checkout", ref.Branch})
1350 mockCmd.EXPECT().Git([]string{"status", "-uno"}).Return(state, nil)
1352 switch state {
1353 case BranchIsBehind:
1354 mockCmd.EXPECT().Git([]string{"pull"}).Return(state, nil)
1356 case BranchHasDiverged:
1357 mockCmd.EXPECT().Git([]string{"checkout", stack.Last().Branch})
1358 mockCmd.EXPECT().Git([]string{"rebase", "--fork-point", "--update-refs", ref.Branch})
1360 case NothingToCommit:
1363 if ref.MR == "" && !tc.args.stack.skipMRCreation && !tc.args.stack.skipPush {
1364 if ref.IsFirst() == true {
1365 if tc.args.stack.baseBranch != "" {
1366 err := git.AddStackBaseBranch(tc.args.stack.title, tc.args.stack.baseBranch)
1367 require.NoError(t, err)
1368 mockCmd.EXPECT().Git([]string{"ls-remote", "--exit-code", "--heads", "origin", tc.args.stack.baseBranch})
1369 } else {
1370 // this is to check for the default branch
1371 mockCmd.EXPECT().Git([]string{"remote", "show", "origin"}).Return("HEAD branch: main", nil)
1372 mockCmd.EXPECT().Git([]string{"ls-remote", "--exit-code", "--heads", "origin", "main"})
1376 // Build push command with --no-verify if noVerify is set
1377 pushCmd := []string{"push", "--set-upstream", "origin"}
1378 if tc.args.stack.noVerify {
1379 pushCmd = append(pushCmd, "--no-verify")
1381 pushCmd = append(pushCmd, ref.Branch)
1382 mockCmd.EXPECT().
1383 GitWithIO(gomock.Any(), gomock.Any(), pushCmd).
1384 Return(nil)
1390 if tc.args.stack.pushNeeded && !tc.args.stack.skipPush {
1391 command := []string{"push", "origin", "--force-with-lease"}
1392 if tc.args.stack.noVerify {
1393 command = append(command, "--no-verify")
1395 command = append(command, stack.Branches()...)
1396 mockCmd.EXPECT().
1397 GitWithIO(gomock.Any(), gomock.Any(), command).
1398 Return(tc.args.stack.pushErr)
1401 err = opts.run(t.Context(), f, mockCmd)
1403 if tc.wantErr {
1404 require.Error(t, err)
1405 if tc.wantErrMsg != "" {
1406 assert.Contains(t, err.Error(), tc.wantErrMsg)
1408 if tc.wantErrIs != nil {
1409 require.ErrorIs(t, err, tc.wantErrIs)
1411 } else {
1412 require.NoError(t, err)
1415 const templateWarning = "[Warning] --template is ignored with --skip-push or --skip-mr-creation."
1416 if tc.wantTemplateWarning {
1417 assert.Contains(t, stderr.String(), templateWarning)
1418 } else {
1419 assert.NotContains(t, stderr.String(), templateWarning)
1422 if tc.args.stack.pushNeeded && tc.args.stack.skipPush {
1423 stdoutText := stdout.String()
1424 assert.Contains(t, stdoutText, "Skipped pushing branches:")
1425 if len(tc.args.stack.wantSkippedBranches) > 0 {
1426 want := "Skipped pushing branches: \n " +
1427 strings.Join(tc.args.stack.wantSkippedBranches, ", ")
1428 assert.Contains(t, stdout.String(), want)
1431 })
1435func TestCreateMRStreamsFailedHookOutput(t *testing.T) {
1436 t.Parallel()
1438 ios, _, stdout, stderr := cmdtest.TestIOStreams()
1439 opts := &options{
1440 io: ios,
1441 target: glrepo.TestProject("stack_guy", "stackproject"),
1443 ref := &git.StackRef{SHA: "1", Branch: "feature-branch"}
1444 hookErr := errors.New("create hook rejected push")
1446 ctrl := gomock.NewController(t)
1447 mockGit := git_testing.NewMockGitRunner(ctrl)
1448 mockGit.EXPECT().
1449 GitWithIO(
1450 ios.StdOut,
1451 ios.StdErr,
1452 "push",
1453 "--set-upstream",
1454 git.DefaultRemote,
1455 ref.Branch,
1456 ).
1457 DoAndReturn(func(out, errOut io.Writer, _ ...string) error {
1458 _, err := io.WriteString(out, "hook stdout: create rejected\n")
1459 require.NoError(t, err)
1460 _, err = io.WriteString(errOut, "hook stderr: create rejected\n")
1461 require.NoError(t, err)
1462 return hookErr
1463 })
1465 _, err := createMR(nil, opts, ref, mockGit)
1467 require.Error(t, err)
1468 require.ErrorIs(t, err, hookErr)
1469 assert.Contains(t, err.Error(), "error pushing branch")
1470 assert.Contains(t, stdout.String(), "hook stdout: create rejected")
1471 assert.Contains(t, stderr.String(), "hook stderr: create rejected")
1474func TestForcePushAllWithLeaseStreamsFailedHookOutput(t *testing.T) {
1475 t.Parallel()
1477 ios, _, stdout, stderr := cmdtest.TestIOStreams()
1478 opts := &options{io: ios}
1479 stack := &git.Stack{
1480 Title: "test-stack",
1481 Refs: map[string]git.StackRef{
1482 "1": {SHA: "1", Branch: "feature-branch"},
1483 },
1485 hookErr := errors.New("force hook rejected push")
1487 ctrl := gomock.NewController(t)
1488 mockGit := git_testing.NewMockGitRunner(ctrl)
1489 mockGit.EXPECT().
1490 GitWithIO(
1491 ios.StdOut,
1492 ios.StdErr,
1493 "push",
1494 git.DefaultRemote,
1495 "--force-with-lease",
1496 "feature-branch",
1497 ).
1498 DoAndReturn(func(out, errOut io.Writer, _ ...string) error {
1499 _, err := io.WriteString(out, "hook stdout: force rejected\n")
1500 require.NoError(t, err)
1501 _, err = io.WriteString(errOut, "hook stderr: force rejected\n")
1502 require.NoError(t, err)
1503 return hookErr
1504 })
1506 err := forcePushAllWithLease(opts, stack, mockGit)
1508 require.Error(t, err)
1509 require.ErrorIs(t, err, hookErr)
1510 assert.Contains(t, stdout.String(), "hook stdout: force rejected")
1511 assert.Contains(t, stderr.String(), "hook stderr: force rejected")
1514func TestForcePushAllWithLeaseStreamsSuccessfulOutputInOrder(t *testing.T) {
1515 t.Parallel()
1517 ios, _, stdout, stderr := cmdtest.TestIOStreams()
1518 opts := &options{io: ios}
1519 stack := &git.Stack{
1520 Title: "test-stack",
1521 Refs: map[string]git.StackRef{
1522 "1": {SHA: "1", Branch: "feature-branch"},
1523 },
1526 ctrl := gomock.NewController(t)
1527 mockGit := git_testing.NewMockGitRunner(ctrl)
1528 mockGit.EXPECT().
1529 GitWithIO(
1530 ios.StdOut,
1531 ios.StdErr,
1532 "push",
1533 git.DefaultRemote,
1534 "--force-with-lease",
1535 "feature-branch",
1536 ).
1537 DoAndReturn(func(out, errOut io.Writer, _ ...string) error {
1538 _, err := io.WriteString(out, "hook stdout: force accepted\n")
1539 require.NoError(t, err)
1540 _, err = io.WriteString(errOut, "hook stderr: force accepted\n")
1541 require.NoError(t, err)
1542 return nil
1543 })
1545 err := forcePushAllWithLease(opts, stack, mockGit)
1547 require.NoError(t, err)
1549 stdoutText := stdout.String()
1550 assert.Contains(t, stdoutText, " feature-branch\nhook stdout: force accepted\n")
1552 updatingIndex := strings.Index(stdoutText, "Updating branches")
1553 hookIndex := strings.Index(stdoutText, "hook stdout: force accepted")
1554 successIndex := strings.Index(stdoutText, "Push succeeded")
1555 require.GreaterOrEqual(t, updatingIndex, 0)
1556 require.GreaterOrEqual(t, hookIndex, 0)
1557 require.GreaterOrEqual(t, successIndex, 0)
1558 assert.Greater(t, hookIndex, updatingIndex)
1559 assert.Greater(t, successIndex, hookIndex)
1561 assert.Equal(t, 1, strings.Count(stdoutText, "Updating branches"))
1562 assert.Equal(t, 1, strings.Count(stdoutText, "hook stdout: force accepted"))
1563 assert.Equal(t, 1, strings.Count(stdoutText, "Push succeeded"))
1564 assert.NotContains(t, stdoutText, "Push succeeded:")
1565 assert.NotContains(t, stdoutText, "Push succeeded\n\n")
1567 stderrText := stderr.String()
1568 assert.Equal(t, 1, strings.Count(stderrText, "hook stderr: force accepted"))
1569 assert.NotContains(t, stderrText, "Push succeeded")
1572func createStack(t *testing.T, title string, scenario map[string]TestRef) {
1573 t.Helper()
1574 _ = git.CheckoutNewBranch("main")
1576 for _, ref := range scenario {
1577 err := git.AddStackRefFile(title, ref.ref)
1578 require.NoError(t, err)
1580 err = git.CheckoutNewBranch(ref.ref.Branch)
1581 require.NoError(t, err)
Diagnostics8 git calls · 261 ms
CallStatusSizeTime0261 ms
discover200185 B4 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
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 KiB4 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
git.response.bytes=59849
git.response.cache=UPDATING
git.response.duration_ms=4
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=3
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=2
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=3
git.response.bytes=1857
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1857
git.pkt.payload.max=1830
git.sideband.band1.bytes=1830
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1830
git.pack.trailer=fb03183b7909876778f740d196d7516811003517
Open pack map
fetchtree:0200432 B · 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=432
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=ff2d1e7abc74964e5679ebdb51f1ac0d0dc3aff0
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=432
git.pkt.payload.max=405
git.sideband.band1.bytes=405
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=405
git.pack.trailer=8f3029a269217d94d12d0671e0490fe3d5506303
Open pack map
fetchtree:0200142 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=142
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=2b98e3432ee122253c3de860618f418835d8ee7b
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=142
git.pkt.payload.max=115
git.sideband.band1.bytes=115
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=115
git.pack.trailer=8526d31131397a024a329f09ee9b0c209c0458d2
Open pack map
fetch2006.5 KiB247 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=247
git.response.bytes=6605
git.response.cache=MISS
git.response.duration_ms=247
git.fetch.wants=1e40cedb845c74d9f6b9247f235b58cc3caa8d47
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=6605
git.pkt.payload.max=6578
git.sideband.band1.bytes=6578
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
a5e159e70ab4cf6a
Request
ccb08077…
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