GitLabgitlab-org
cli
main
1//go:build !integration
3package reorder
5import (
6 "fmt"
7 "net/http"
8 "os"
9 "strings"
10 "testing"
12 "github.com/spf13/cobra"
13 "github.com/stretchr/testify/assert"
14 "github.com/stretchr/testify/require"
15 "go.uber.org/mock/gomock"
17 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
18 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
20 "gitlab.com/gitlab-org/cli/internal/api"
21 "gitlab.com/gitlab-org/cli/internal/cmdutils"
22 "gitlab.com/gitlab-org/cli/internal/config"
23 "gitlab.com/gitlab-org/cli/internal/git"
24 gittesting "gitlab.com/gitlab-org/cli/internal/git/testing"
25 "gitlab.com/gitlab-org/cli/internal/glrepo"
26 "gitlab.com/gitlab-org/cli/internal/run"
27 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
28)
30func Test_matchBranchesToStack(t *testing.T) {
31 type args struct {
32 stack git.Stack
33 branches []string
34 }
35 tests := []struct {
36 name string
37 args args
38 expected git.Stack
39 wantErr bool
40 }{
41 {
42 name: "basic situation",
43 args: args{
44 stack: git.Stack{
45 Refs: map[string]git.StackRef{
46 "123": {SHA: "123", Prev: "", Next: "456", Branch: "Branch1", Description: "blah1"},
47 "456": {SHA: "456", Prev: "123", Next: "789", Branch: "Branch2", Description: "blah2"},
48 "789": {SHA: "789", Prev: "456", Next: "", Branch: "Branch3", Description: "blah3"},
49 },
50 },
51 branches: []string{"Branch2", "Branch3", "Branch1"},
52 },
53 expected: git.Stack{
54 Refs: map[string]git.StackRef{
55 "456": {SHA: "456", Prev: "", Next: "789", Branch: "Branch2", Description: "blah2"},
56 "789": {SHA: "789", Prev: "456", Next: "123", Branch: "Branch3", Description: "blah3"},
57 "123": {SHA: "123", Prev: "789", Next: "", Branch: "Branch1", Description: "blah1"},
58 },
59 },
60 },
62 {
63 name: "missing branches from reordered list",
64 args: args{
65 stack: git.Stack{
66 Refs: map[string]git.StackRef{
67 "123": {SHA: "123", Prev: "", Next: "456", Branch: "Branch1"},
68 "456": {SHA: "456", Prev: "123", Next: "789", Branch: "Branch2"},
69 "789": {SHA: "789", Prev: "456", Next: "", Branch: "Branch3"},
70 },
71 },
72 branches: []string{"Branch2", "Branch1"},
73 },
74 expected: git.Stack{},
75 wantErr: true,
76 },
78 {
79 name: "duplicate branch in reordered list",
80 args: args{
81 stack: git.Stack{
82 Refs: map[string]git.StackRef{
83 "123": {SHA: "123", Prev: "", Next: "456", Branch: "Branch1"},
84 "456": {SHA: "456", Prev: "123", Next: "", Branch: "Branch2"},
85 },
86 },
87 branches: []string{"Branch1", "Branch1"},
88 },
89 expected: git.Stack{},
90 wantErr: true,
91 },
93 {
94 name: "large stack",
95 args: args{
96 stack: git.Stack{
97 Refs: map[string]git.StackRef{
98 "1": {SHA: "1", Prev: "", Next: "2", Branch: "Branch1"},
99 "2": {SHA: "2", Prev: "1", Next: "3", Branch: "Branch2"},
100 "3": {SHA: "3", Prev: "2", Next: "4", Branch: "Branch3"},
101 "4": {SHA: "4", Prev: "3", Next: "5", Branch: "Branch4"},
102 "5": {SHA: "5", Prev: "4", Next: "6", Branch: "Branch5"},
103 "6": {SHA: "6", Prev: "5", Next: "7", Branch: "Branch6"},
104 "7": {SHA: "7", Prev: "6", Next: "8", Branch: "Branch7"},
105 "8": {SHA: "8", Prev: "7", Next: "9", Branch: "Branch8"},
106 "9": {SHA: "9", Prev: "8", Next: "10", Branch: "Branch9"},
107 "10": {SHA: "10", Prev: "9", Next: "11", Branch: "Branch10"},
108 "11": {SHA: "11", Prev: "10", Next: "12", Branch: "Branch11"},
109 "12": {SHA: "12", Prev: "11", Next: "13", Branch: "Branch12"},
110 "13": {SHA: "13", Prev: "12", Next: "", Branch: "Branch13"},
111 },
112 },
113 branches: []string{
114 "Branch12",
115 "Branch1",
116 "Branch2",
117 "Branch8",
118 "Branch11",
119 "Branch3",
120 "Branch6",
121 "Branch9",
122 "Branch7",
123 "Branch5",
124 "Branch10",
125 "Branch13",
126 "Branch4",
127 },
128 },
129 expected: git.Stack{
130 Refs: map[string]git.StackRef{
131 "12": {SHA: "12", Prev: "", Next: "1", Branch: "Branch12"},
132 "1": {SHA: "1", Prev: "12", Next: "2", Branch: "Branch1"},
133 "2": {SHA: "2", Prev: "1", Next: "8", Branch: "Branch2"},
134 "8": {SHA: "8", Prev: "2", Next: "11", Branch: "Branch8"},
135 "11": {SHA: "11", Prev: "8", Next: "3", Branch: "Branch11"},
136 "3": {SHA: "3", Prev: "11", Next: "6", Branch: "Branch3"},
137 "6": {SHA: "6", Prev: "3", Next: "9", Branch: "Branch6"},
138 "9": {SHA: "9", Prev: "6", Next: "7", Branch: "Branch9"},
139 "7": {SHA: "7", Prev: "9", Next: "5", Branch: "Branch7"},
140 "5": {SHA: "5", Prev: "7", Next: "10", Branch: "Branch5"},
141 "10": {SHA: "10", Prev: "5", Next: "13", Branch: "Branch10"},
142 "13": {SHA: "13", Prev: "10", Next: "4", Branch: "Branch13"},
143 "4": {SHA: "4", Prev: "13", Next: "", Branch: "Branch4"},
144 },
145 },
146 },
147 }
149 for _, tt := range tests {
150 t.Run(tt.name, func(t *testing.T) {
151 git.InitGitRepo(t)
153 err := git.CreateRefFiles(tt.args.stack.Refs, "cool stack")
154 require.NoError(t, err)
156 git.CreateBranches(t, tt.args.branches)
158 newStack, err := matchBranchesToStack(tt.args.stack, tt.args.branches)
160 onDisk, gatherErr := git.GatherStackRefs("cool stack")
161 require.NoError(t, gatherErr)
162 require.Equal(t, tt.args.stack.Refs, onDisk.Refs, "ref files must not change until the rebases finish")
164 if tt.wantErr {
165 require.Error(t, err)
166 } else {
167 for k, ref := range tt.expected.Refs {
168 require.Equal(t, newStack.Refs[k], ref)
169 }
171 require.Len(t, newStack.Refs, len(tt.args.branches))
172 }
173 })
174 }
175}
177func setupTestFactoryForReorder(t *testing.T, testClient *gitlabtesting.TestClient) cmdutils.Factory {
178 t.Helper()
180 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
182 return cmdtest.NewTestFactory(ios, reorderFactoryOptions(t, testClient)...)
183}
185// reorderFactoryOptions wires the mock client into the factory. The config
186// needs a host because the reorder MR update checks for one before any API call.
187func reorderFactoryOptions(t *testing.T, testClient *gitlabtesting.TestClient) []cmdtest.FactoryOption {
188 t.Helper()
190 apiClient, err := api.NewClient(
191 func(*http.Client) (gitlab.AuthSource, error) {
192 return gitlab.AccessTokenAuthSource{Token: ""}, nil
193 },
194 api.WithGitLabClient(testClient.Client),
195 )
196 require.NoError(t, err)
198 return []cmdtest.FactoryOption{
199 cmdtest.WithGitLabClient(testClient.Client),
200 cmdtest.WithConfig(config.NewFromString("hosts:\n gitlab.com:\n token: test-token\n")),
201 func(f *cmdtest.Factory) {
202 f.BaseRepoStub = func() (glrepo.Interface, error) {
203 return glrepo.TestProject("stack_guy", "stackproject"), nil
204 }
205 f.ApiClientStub = func(repoHost string) (*api.Client, error) {
206 return apiClient, nil
207 }
208 },
209 }
210}
212type retarget struct {
213 iid int64
214 target string
215}
217// expectRetargets mocks the lookup and target-branch update for each branch's MR.
218// Lookups are matched by source branch, so the order updateMRs visits them in does not matter.
219func expectRetargets(t *testing.T, testClient *gitlabtesting.TestClient, want map[string]retarget) {
220 t.Helper()
222 testClient.MockMergeRequests.EXPECT().
223 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
224 Times(len(want)).
225 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
226 r, ok := want[*opts.SourceBranch]
227 require.True(t, ok, "unexpected MR lookup for branch %q", *opts.SourceBranch)
228 return []*gitlab.BasicMergeRequest{{
229 ID: r.iid, IID: r.iid, ProjectID: 3, SourceBranch: *opts.SourceBranch, State: "opened",
230 }}, nil, nil
231 })
233 for branch, r := range want {
234 testClient.MockMergeRequests.EXPECT().
235 GetMergeRequest("stack_guy/stackproject", r.iid, gomock.Any()).
236 Return(&gitlab.MergeRequest{BasicMergeRequest: gitlab.BasicMergeRequest{
237 ID: r.iid, IID: r.iid, ProjectID: 3, SourceBranch: branch, State: "opened",
238 }}, nil, nil)
240 testClient.MockMergeRequests.EXPECT().
241 UpdateMergeRequest(int64(3), r.iid, gomock.Any()).
242 DoAndReturn(func(pid any, iid int64, opts *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
243 assert.Equal(t, r.target, *opts.TargetBranch, "target branch for %s", branch)
244 return &gitlab.MergeRequest{BasicMergeRequest: gitlab.BasicMergeRequest{IID: iid, TargetBranch: r.target}}, nil, nil
245 })
246 }
247}
249func Test_updateMRs(t *testing.T) {
250 type args struct {
251 newStack git.Stack
252 oldStack git.Stack
253 setupMocks func(t *testing.T, testClient *gitlabtesting.TestClient)
254 }
255 tests := []struct {
256 name string
257 args args
258 wantErr bool
259 }{
260 {
261 name: "update a complex stack",
262 args: args{
263 newStack: git.Stack{
264 Refs: map[string]git.StackRef{
265 "7": {
266 SHA: "7", Prev: "", Next: "5", Branch: "Branch7",
267 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/7",
268 },
269 "5": {
270 SHA: "5", Prev: "7", Next: "8", Branch: "Branch5",
271 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/5",
272 },
273 "8": {
274 SHA: "8", Prev: "5", Next: "1", Branch: "Branch8",
275 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/8",
276 },
277 "1": {
278 SHA: "1", Prev: "8", Next: "9", Branch: "Branch1",
279 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
280 },
281 "9": {
282 SHA: "9", Prev: "1", Next: "4", Branch: "Branch9",
283 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/9",
284 },
285 "4": {
286 SHA: "4", Prev: "9", Next: "2", Branch: "Branch4",
287 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/4",
288 },
289 "2": {
290 SHA: "2", Prev: "4", Next: "3", Branch: "Branch2",
291 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
292 },
293 "3": {
294 SHA: "3", Prev: "2", Next: "6", Branch: "Branch3",
295 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/3",
296 },
297 "6": {
298 SHA: "6", Prev: "3", Next: "10", Branch: "Branch6",
299 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/6",
300 },
301 "10": {
302 SHA: "10", Prev: "6", Next: "12", Branch: "Branch10",
303 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/10",
304 },
305 "12": {
306 SHA: "12", Prev: "10", Next: "11", Branch: "Branch12",
307 MR: "",
308 },
309 "11": {
310 SHA: "11", Prev: "12", Next: "13", Branch: "Branch11",
311 MR: "",
312 },
313 "13": {
314 SHA: "13", Prev: "11", Next: "", Branch: "Branch13",
315 MR: "",
316 },
317 },
318 },
320 oldStack: git.Stack{
321 Refs: map[string]git.StackRef{
322 "1": {
323 SHA: "1", Prev: "", Next: "2", Branch: "Branch1",
324 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/1",
325 },
326 "2": {
327 SHA: "2", Prev: "1", Next: "3", Branch: "Branch2",
328 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/2",
329 },
330 "3": {
331 SHA: "3", Prev: "2", Next: "4", Branch: "Branch3",
332 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/3",
333 },
334 "4": {
335 SHA: "4", Prev: "3", Next: "5", Branch: "Branch4",
336 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/4",
337 },
338 "5": {
339 SHA: "5", Prev: "4", Next: "6", Branch: "Branch5",
340 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/5",
341 },
342 "6": {
343 SHA: "6", Prev: "5", Next: "7", Branch: "Branch6",
344 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/6",
345 },
346 "7": {
347 SHA: "7", Prev: "6", Next: "8", Branch: "Branch7",
348 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/7",
349 },
350 "8": {
351 SHA: "8", Prev: "7", Next: "9", Branch: "Branch8",
352 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/8",
353 },
354 "9": {
355 SHA: "9", Prev: "8", Next: "10", Branch: "Branch9",
356 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/9",
357 },
358 "10": {
359 SHA: "10", Prev: "9", Next: "11", Branch: "Branch10",
360 MR: "http://gitlab.com/stack_guy/stackproject/-/merge_requests/10",
361 },
362 "11": {
363 SHA: "11", Prev: "10", Next: "12", Branch: "Branch11",
364 MR: "",
365 },
366 "12": {
367 SHA: "12", Prev: "11", Next: "13", Branch: "Branch12",
368 MR: "",
369 },
370 "13": {
371 SHA: "13", Prev: "12", Next: "", Branch: "Branch13",
372 MR: "",
373 },
374 },
375 },
376 setupMocks: func(t *testing.T, testClient *gitlabtesting.TestClient) {
377 t.Helper()
378 // For each branch with an MR, we need:
379 // 1. ListProjectMergeRequests (open MRs by source branch)
380 // 2. GetMergeRequest
381 // 3. UpdateMergeRequest (to change target branch)
383 branchesToUpdate := []struct {
384 branch string
385 iid int64
386 newTarget string
387 }{
388 {"Branch7", 7, "main"},
389 {"Branch5", 5, "Branch7"},
390 {"Branch8", 8, "Branch5"},
391 {"Branch1", 1, "Branch8"},
392 {"Branch9", 9, "Branch1"},
393 {"Branch4", 4, "Branch9"},
394 {"Branch2", 2, "Branch4"},
395 {"Branch3", 3, "Branch2"},
396 {"Branch6", 6, "Branch3"},
397 {"Branch10", 10, "Branch6"},
398 }
400 for _, b := range branchesToUpdate {
401 branch := b.branch
402 iid := b.iid
403 newTarget := b.newTarget
405 // MockListOpenStackMRsByBranch
406 testClient.MockMergeRequests.EXPECT().
407 ListProjectMergeRequests("stack_guy/stackproject", gomock.Any()).
408 DoAndReturn(func(pid any, opts *gitlab.ListProjectMergeRequestsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
409 assert.Equal(t, branch, *opts.SourceBranch)
410 assert.Equal(t, "opened", *opts.State)
411 return []*gitlab.BasicMergeRequest{
412 {
413 ID: iid,
414 IID: iid,
415 ProjectID: 3,
416 SourceBranch: branch,
417 State: "opened",
418 },
419 }, nil, nil
420 })
422 // MockGetStackMR
423 testClient.MockMergeRequests.EXPECT().
424 GetMergeRequest("stack_guy/stackproject", iid, gomock.Any()).
425 Return(&gitlab.MergeRequest{
426 BasicMergeRequest: gitlab.BasicMergeRequest{
427 ID: iid,
428 IID: iid,
429 ProjectID: 3,
430 SourceBranch: branch,
431 State: "opened",
432 },
433 }, nil, nil)
435 // MockPutStackMR (UpdateMergeRequest)
436 // Note: UpdateMergeRequest is called with mr.ProjectID (int64) not the string path
437 testClient.MockMergeRequests.EXPECT().
438 UpdateMergeRequest(int64(3), iid, gomock.Any()).
439 DoAndReturn(func(pid any, mrIID int64, opts *gitlab.UpdateMergeRequestOptions, options ...gitlab.RequestOptionFunc) (*gitlab.MergeRequest, *gitlab.Response, error) {
440 assert.Equal(t, newTarget, *opts.TargetBranch)
441 return &gitlab.MergeRequest{
442 BasicMergeRequest: gitlab.BasicMergeRequest{
443 IID: iid,
444 TargetBranch: newTarget,
445 },
446 }, nil, nil
447 })
448 }
449 },
450 },
451 },
452 }
454 for _, tt := range tests {
455 t.Run(tt.name, func(t *testing.T) {
456 git.InitGitRepoWithCommit(t)
458 gitAddRemote := git.GitCommand("remote", "add", "origin", "http://gitlab.com/gitlab-org/cli.git")
459 _, err := run.PrepareCmd(gitAddRemote).Output()
460 require.NoError(t, err)
462 testClient := gitlabtesting.NewTestClient(t)
463 tt.args.setupMocks(t, testClient)
465 factory := setupTestFactoryForReorder(t, testClient)
467 err = updateMRs(t.Context(), factory, testClient.Client, "main", tt.args.newStack, tt.args.oldStack)
469 require.NoError(t, err)
470 })
471 }
472}
474// gitExec is a helper that runs a git command and fails the test on error.
475func gitExec(t *testing.T, args ...string) string {
476 t.Helper()
477 cmd := git.GitCommand(args...)
478 out, err := run.PrepareCmd(cmd).Output()
479 require.NoError(t, err)
480 return strings.TrimSpace(string(out))
481}
483func Test_rebaseInNewOrder(t *testing.T) {
484 t.Run("reorders branches A,B,C to C,A,B", func(t *testing.T) {
485 git.InitGitRepoWithCommit(t)
486 gr := git.StandardGitCommand{}
488 // The default branch from InitGitRepoWithCommit may not be "main",
489 // so create it if it doesn't exist, or just check it out.
490 _ = run.PrepareCmd(git.GitCommand("branch", "-M", "main")).Run()
492 // Create branch A off main with a unique commit
493 gitExec(t, "checkout", "-b", "branchA")
494 require.NoError(t, os.WriteFile("fileA", []byte("A content"), 0o644))
495 gitExec(t, "add", "fileA")
496 gitExec(t, "commit", "-m", "commit A")
498 // Create branch B off A with a unique commit
499 gitExec(t, "checkout", "-b", "branchB")
500 require.NoError(t, os.WriteFile("fileB", []byte("B content"), 0o644))
501 gitExec(t, "add", "fileB")
502 gitExec(t, "commit", "-m", "commit B")
504 // Create branch C off B with a unique commit
505 gitExec(t, "checkout", "-b", "branchC")
506 require.NoError(t, os.WriteFile("fileC", []byte("C content"), 0o644))
507 gitExec(t, "add", "fileC")
508 gitExec(t, "commit", "-m", "commit C")
510 // Go back to branchA (simulating user's current branch)
511 gitExec(t, "checkout", "branchA")
513 // Old stack: A -> B -> C
514 oldStack := git.Stack{
515 Title: "test-stack",
516 Refs: map[string]git.StackRef{
517 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
518 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "ref-c", Branch: "branchB"},
519 "ref-c": {SHA: "ref-c", Prev: "ref-b", Next: "", Branch: "branchC"},
520 },
521 }
523 // New stack: C -> A -> B
524 newStack := git.Stack{
525 Title: "test-stack",
526 Refs: map[string]git.StackRef{
527 "ref-c": {SHA: "ref-c", Prev: "", Next: "ref-a", Branch: "branchC"},
528 "ref-a": {SHA: "ref-a", Prev: "ref-c", Next: "ref-b", Branch: "branchA"},
529 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
530 },
531 }
533 // Write stack ref files (creates the stack directory) and base branch metadata
534 require.NoError(t, git.CreateRefFiles(oldStack.Refs, "test-stack"))
535 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
537 _, err := rebaseInNewOrder(gr, oldStack, newStack)
538 require.NoError(t, err)
540 // Verify we're back on branchA
541 currentBranch, err := git.CurrentBranch()
542 require.NoError(t, err)
543 assert.Equal(t, "branchA", currentBranch)
545 mainTip := gitExec(t, "rev-parse", "main")
547 // branchC should be directly on top of main, containing only fileC
548 // (not fileA or fileB from the old order)
549 cParent := gitExec(t, "rev-parse", "branchC~1")
550 assert.Equal(t, mainTip, cParent, "branchC's parent should be main")
551 cLog := gitExec(t, "log", "--oneline", "main..branchC")
552 assert.Equal(t, 1, strings.Count(cLog, "\n")+1, "branchC should have exactly 1 commit on top of main")
554 // branchA should be on top of branchC
555 aParent := gitExec(t, "rev-parse", "branchA~1")
556 cTip := gitExec(t, "rev-parse", "branchC")
557 assert.Equal(t, cTip, aParent, "branchA's parent should be branchC")
559 // branchB should be on top of branchA
560 bParent := gitExec(t, "rev-parse", "branchB~1")
561 aTip := gitExec(t, "rev-parse", "branchA")
562 assert.Equal(t, aTip, bParent, "branchB's parent should be branchA")
564 // Verify each branch has the right files
565 gitExec(t, "checkout", "branchC")
566 _, errStat := os.Stat("fileC")
567 require.NoError(t, errStat, "branchC should have fileC")
569 gitExec(t, "checkout", "branchA")
570 _, errStat = os.Stat("fileA")
571 require.NoError(t, errStat, "branchA should have fileA")
572 _, errStat = os.Stat("fileC")
573 require.NoError(t, errStat, "branchA should have fileC (inherited from branchC)")
575 gitExec(t, "checkout", "branchB")
576 _, errStat = os.Stat("fileB")
577 require.NoError(t, errStat, "branchB should have fileB")
578 _, errStat = os.Stat("fileA")
579 require.NoError(t, errStat, "branchB should have fileA (inherited from branchA)")
580 })
582 t.Run("conflict produces useful error", func(t *testing.T) {
583 oldStack := git.Stack{
584 Title: "test-stack",
585 Refs: map[string]git.StackRef{
586 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
587 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
588 },
589 }
591 newStack := git.Stack{
592 Title: "test-stack",
593 Refs: map[string]git.StackRef{
594 "ref-b": {SHA: "ref-b", Prev: "", Next: "ref-a", Branch: "branchB"},
595 "ref-a": {SHA: "ref-a", Prev: "ref-b", Next: "", Branch: "branchA"},
596 },
597 }
599 // Need a git repo with a commit for CurrentBranch() to work
600 git.InitGitRepoWithCommit(t)
601 require.NoError(t, git.CreateRefFiles(oldStack.Refs, "test-stack"))
602 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
604 ctrl := gomock.NewController(t)
605 mockGr := gittesting.NewMockGitRunner(ctrl)
607 gomock.InOrder(
608 mockGr.EXPECT().Git("rev-parse", "branchA").Return("aaaa\n", nil),
609 mockGr.EXPECT().Git("rev-parse", "branchB").Return("bbbb\n", nil),
610 mockGr.EXPECT().Git("rev-parse", "main").Return("0000\n", nil),
611 // checkout branchB (first in new order)
612 mockGr.EXPECT().Git("checkout", "branchB").Return("", nil),
613 // rebase stops on a conflict, leaving a rebase in progress
614 mockGr.EXPECT().Git("rebase", "--onto", "main", "aaaa").
615 DoAndReturn(func(...string) (string, error) {
616 require.NoError(t, os.MkdirAll(".git/rebase-merge", 0o755))
617 return "", fmt.Errorf("conflict")
618 }),
619 )
621 _, err := rebaseInNewOrder(mockGr, oldStack, newStack)
622 require.Error(t, err)
623 assert.Contains(t, err.Error(), "rebase conflict on branchB onto main")
624 assert.Contains(t, err.Error(), "glab stack reorder --continue")
625 assert.Contains(t, err.Error(), "glab stack reorder --abort")
627 // Verify state file was persisted with correct NextIndex
628 state, stateErr := git.ReadReorderState("test-stack")
629 require.NoError(t, stateErr)
630 assert.Equal(t, 0, state.NextIndex, "NextIndex should point to the failed branch")
631 })
633 t.Run("refused rebase reports git's error, not a conflict", func(t *testing.T) {
634 oldStack := git.Stack{
635 Title: "test-stack",
636 Refs: map[string]git.StackRef{
637 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
638 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
639 },
640 }
642 newStack := git.Stack{
643 Title: "test-stack",
644 Refs: map[string]git.StackRef{
645 "ref-b": {SHA: "ref-b", Prev: "", Next: "ref-a", Branch: "branchB"},
646 "ref-a": {SHA: "ref-a", Prev: "ref-b", Next: "", Branch: "branchA"},
647 },
648 }
650 git.InitGitRepoWithCommit(t)
651 require.NoError(t, git.CreateRefFiles(oldStack.Refs, "test-stack"))
652 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
654 ctrl := gomock.NewController(t)
655 mockGr := gittesting.NewMockGitRunner(ctrl)
657 gomock.InOrder(
658 mockGr.EXPECT().Git("rev-parse", "branchA").Return("aaaa\n", nil),
659 mockGr.EXPECT().Git("rev-parse", "branchB").Return("bbbb\n", nil),
660 mockGr.EXPECT().Git("rev-parse", "main").Return("0000\n", nil),
661 mockGr.EXPECT().Git("checkout", "branchB").Return("", nil),
662 // git refuses to start, so no rebase is left in progress
663 mockGr.EXPECT().Git("rebase", "--onto", "main", "aaaa").
664 Return("", fmt.Errorf("cannot rebase: You have unstaged changes")),
665 )
667 _, err := rebaseInNewOrder(mockGr, oldStack, newStack)
668 require.Error(t, err)
669 assert.Contains(t, err.Error(), "could not rebase branchB onto main")
670 assert.Contains(t, err.Error(), "cannot rebase: You have unstaged changes")
671 assert.Contains(t, err.Error(), "glab stack reorder --abort")
672 assert.NotContains(t, err.Error(), "rebase conflict")
674 state, stateErr := git.ReadReorderState("test-stack")
675 require.NoError(t, stateErr)
676 assert.Equal(t, 0, state.NextIndex, "state must be kept so --abort can restore the branches")
677 })
678}
680func Test_normalFlow_uncommittedChanges_errorsBeforeEditor(t *testing.T) {
681 git.InitGitRepoWithCommit(t)
683 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
684 "ref-a": {SHA: "ref-a", Prev: "", Next: "", Branch: "branchA"},
685 }, "test-stack"))
686 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
688 ctrl := gomock.NewController(t)
689 mockGr := gittesting.NewMockGitRunner(ctrl)
690 mockGr.EXPECT().Git("status", "--porcelain", "--untracked-files=no").Return(" M file\n", nil)
692 // A nil editor func panics if called, so reaching it fails the test.
693 err := runReorderCmd(t, mockGr, "")
694 require.Error(t, err)
695 assert.Contains(t, err.Error(), "uncommitted changes")
696}
698func Test_continueFlow_uncommittedChanges_errors(t *testing.T) {
699 git.InitGitRepoWithCommit(t)
700 writePausedReorder(t)
702 ctrl := gomock.NewController(t)
703 mockGr := gittesting.NewMockGitRunner(ctrl)
704 mockGr.EXPECT().Git("status", "--porcelain", "--untracked-files=no").Return(" M file\n", nil)
706 err := runReorderCmd(t, mockGr, "--continue")
707 require.Error(t, err)
708 assert.Contains(t, err.Error(), "uncommitted changes")
710 got, readErr := git.ReadReorderState("test-stack")
711 require.NoError(t, readErr)
712 assert.Equal(t, 1, got.NextIndex)
713}
715func Test_executeRebases_resumesFromNextIndex(t *testing.T) {
716 git.InitGitRepoWithCommit(t)
717 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
718 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
719 }, "test-stack"))
720 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
722 ctrl := gomock.NewController(t)
723 mockGr := gittesting.NewMockGitRunner(ctrl)
725 // State simulates: branchB already done (NextIndex=1), branchA still to do
726 state := git.ReorderState{
727 NewOrder: []string{"branchB", "branchA"},
728 NextIndex: 1,
729 OldTips: map[string]string{"branchA": "aaaa", "branchB": "bbbb", "main": "0000"},
730 OldParent: map[string]string{"branchA": "main", "branchB": "branchA"},
731 BaseBranch: "main",
732 OriginalBranch: "branchA",
733 }
735 // Should only rebase branchA (index 1), not branchB (index 0)
736 gomock.InOrder(
737 mockGr.EXPECT().Git("checkout", "branchA").Return("", nil),
738 mockGr.EXPECT().Git("rebase", "--onto", "branchB", "0000").Return("", nil),
739 mockGr.EXPECT().Git("checkout", "branchA").Return("", nil), // restore original
740 )
742 err := executeRebases(mockGr, "test-stack", &state)
743 require.NoError(t, err)
744 assert.Equal(t, 2, state.NextIndex)
745}
747func Test_abortFlow_resetsAndRestores(t *testing.T) {
748 git.InitGitRepoWithCommit(t)
750 oldRefs := map[string]git.StackRef{
751 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
752 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
753 }
755 require.NoError(t, git.CreateRefFiles(oldRefs, "test-stack"))
756 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
758 // Write a state file as if a reorder is in progress
759 state := git.ReorderState{
760 NewOrder: []string{"branchB", "branchA"},
761 NextIndex: 1,
762 OldTips: map[string]string{"branchA": "aaaa", "branchB": "bbbb", "main": "0000"},
763 OldParent: map[string]string{"branchA": "main", "branchB": "branchA"},
764 BaseBranch: "main",
765 OriginalBranch: "branchA",
766 OldRefs: oldRefs,
767 }
768 require.NoError(t, git.WriteReorderState("test-stack", state))
770 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
772 ctrl := gomock.NewController(t)
773 mockGr := gittesting.NewMockGitRunner(ctrl)
775 // The checked-out branch is reset with --keep; the rest move without a checkout.
776 gomock.InOrder(
777 mockGr.EXPECT().Git("rebase", "--abort").Return("", nil),
778 mockGr.EXPECT().Git("symbolic-ref", "--quiet", "--short", "HEAD").Return("branchA\n", nil),
779 mockGr.EXPECT().Git("reset", "--keep", "aaaa").Return("", nil),
780 mockGr.EXPECT().Git("branch", "-f", "branchB", "bbbb").Return("", nil),
781 mockGr.EXPECT().Git("checkout", "branchA").Return("", nil), // restore original
782 )
784 err := runReorderCmd(t, mockGr, "--abort")
785 require.NoError(t, err)
787 // Verify state file was deleted
788 inProgress, err := git.ReorderInProgress("test-stack")
789 require.NoError(t, err)
790 assert.False(t, inProgress)
792 onDisk, err := git.GatherStackRefs("test-stack")
793 require.NoError(t, err)
794 assert.Equal(t, oldRefs, onDisk.Refs, "abort must leave the ref files in the old order")
795}
797func Test_abortFlow_detachedHead_movesEveryBranch(t *testing.T) {
798 git.InitGitRepoWithCommit(t)
799 writePausedReorder(t)
801 ctrl := gomock.NewController(t)
802 mockGr := gittesting.NewMockGitRunner(ctrl)
804 gomock.InOrder(
805 mockGr.EXPECT().Git("rebase", "--abort").Return("", nil),
806 mockGr.EXPECT().Git("symbolic-ref", "--quiet", "--short", "HEAD").Return("", fmt.Errorf("exit status 1")),
807 mockGr.EXPECT().Git("branch", "-f", "branchA", "aaaa").Return("", nil),
808 mockGr.EXPECT().Git("branch", "-f", "branchB", "bbbb").Return("", nil),
809 mockGr.EXPECT().Git("checkout", "branchA").Return("", nil),
810 )
812 require.NoError(t, runReorderCmd(t, mockGr, "--abort"))
813}
815func Test_abortFlow_uncommittedChanges_stopsBeforeMovingBranches(t *testing.T) {
816 git.InitGitRepoWithCommit(t)
817 writePausedReorder(t)
819 ctrl := gomock.NewController(t)
820 mockGr := gittesting.NewMockGitRunner(ctrl)
822 // No `branch -f` expectations: a refused reset must leave the other branches alone.
823 gomock.InOrder(
824 mockGr.EXPECT().Git("rebase", "--abort").Return("", nil),
825 mockGr.EXPECT().Git("symbolic-ref", "--quiet", "--short", "HEAD").Return("branchA\n", nil),
826 mockGr.EXPECT().Git("reset", "--keep", "aaaa").Return("", fmt.Errorf("entry 'f' not uptodate. Cannot merge")),
827 )
829 err := runReorderCmd(t, mockGr, "--abort")
830 require.Error(t, err)
831 assert.Contains(t, err.Error(), "Commit or stash them")
833 inProgress, err := git.ReorderInProgress("test-stack")
834 require.NoError(t, err)
835 assert.True(t, inProgress, "state must be kept so --abort can be retried")
836}
838func writePausedReorder(t *testing.T) {
839 t.Helper()
841 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
842 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
843 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
844 }, "test-stack"))
845 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
846 require.NoError(t, git.WriteReorderState("test-stack", git.ReorderState{
847 NewOrder: []string{"branchB", "branchA"},
848 NextIndex: 1,
849 OldTips: map[string]string{"branchA": "aaaa", "branchB": "bbbb", "main": "0000"},
850 BaseBranch: "main",
851 OriginalBranch: "branchA",
852 }))
853}
855func Test_abortFlow_noStateFile(t *testing.T) {
856 git.InitGitRepoWithCommit(t)
858 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
859 "ref-a": {SHA: "ref-a", Prev: "", Next: "", Branch: "branchA"},
860 }, "test-stack"))
861 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
863 err := runReorderCmd(t, git.StandardGitCommand{}, "--abort")
864 require.Error(t, err)
865 assert.Contains(t, err.Error(), "no reorder in progress")
866}
868func Test_abortFlow_refusedAfterRebasesComplete(t *testing.T) {
869 git.InitGitRepoWithCommit(t)
871 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
872 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
873 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
874 }, "test-stack"))
875 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
877 state := git.ReorderState{
878 NewOrder: []string{"branchB", "branchA"},
879 NextIndex: 2,
880 BaseBranch: "main",
881 OriginalBranch: "branchA",
882 }
883 require.NoError(t, git.WriteReorderState("test-stack", state))
885 ctrl := gomock.NewController(t)
886 mockGr := gittesting.NewMockGitRunner(ctrl)
888 err := runReorderCmd(t, mockGr, "--abort")
889 require.Error(t, err)
890 assert.Contains(t, err.Error(), "cannot abort")
891 assert.Contains(t, err.Error(), "glab stack reorder --continue")
893 inProgress, err := git.ReorderInProgress("test-stack")
894 require.NoError(t, err)
895 assert.True(t, inProgress, "state must be kept so --continue can finish the reorder")
896}
898func Test_normalFlow_blockedByInProgressReorder(t *testing.T) {
899 git.InitGitRepoWithCommit(t)
901 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
902 "ref-a": {SHA: "ref-a", Prev: "", Next: "", Branch: "branchA"},
903 }, "test-stack"))
904 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
906 // Write a state file to simulate an in-progress reorder.
907 state := git.ReorderState{NewOrder: []string{"branchA"}}
908 require.NoError(t, git.WriteReorderState("test-stack", state))
910 // A fresh `glab stack reorder` must refuse to start while one is in progress.
911 err := runReorderCmd(t, git.StandardGitCommand{}, "")
912 require.Error(t, err)
913 assert.Contains(t, err.Error(), "a stack reorder is in progress")
914}
916func Test_continueFlow_noStateFile(t *testing.T) {
917 git.InitGitRepoWithCommit(t)
919 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
920 "ref-a": {SHA: "ref-a", Prev: "", Next: "", Branch: "branchA"},
921 }, "test-stack"))
922 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
924 // No state file written, so there is nothing to continue.
925 err := runReorderCmd(t, git.StandardGitCommand{}, "--continue")
926 require.Error(t, err)
927 assert.Contains(t, err.Error(), "no reorder in progress")
928}
930func Test_continueFlow_invalidIndex(t *testing.T) {
931 git.InitGitRepoWithCommit(t)
933 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
934 "ref-a": {SHA: "ref-a", Prev: "", Next: "", Branch: "branchA"},
935 }, "test-stack"))
936 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
938 // NextIndex points past the end of NewOrder — a corrupt/invalid state.
939 state := git.ReorderState{NewOrder: []string{"branchA"}, NextIndex: 2}
940 require.NoError(t, git.WriteReorderState("test-stack", state))
942 err := runReorderCmd(t, git.StandardGitCommand{}, "--continue")
943 require.Error(t, err)
944 assert.Contains(t, err.Error(), "out of range")
945}
947func Test_continueFlow_gitRebaseInProgress_errors(t *testing.T) {
948 git.InitGitRepoWithCommit(t)
950 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
951 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
952 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
953 }, "test-stack"))
954 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
956 state := git.ReorderState{
957 NewOrder: []string{"branchB", "branchA"},
958 NextIndex: 0,
959 BaseBranch: "main",
960 OriginalBranch: "branchA",
961 }
962 require.NoError(t, git.WriteReorderState("test-stack", state))
964 require.NoError(t, os.MkdirAll(".git/rebase-merge", 0o755))
966 // No expectations: --continue must not run `git rebase --continue` itself.
967 ctrl := gomock.NewController(t)
968 mockGr := gittesting.NewMockGitRunner(ctrl)
970 err := runReorderCmd(t, mockGr, "--continue")
971 require.Error(t, err)
972 assert.Contains(t, err.Error(), "still in progress")
973 assert.Contains(t, err.Error(), "git rebase --continue")
975 got, readErr := git.ReadReorderState("test-stack")
976 require.NoError(t, readErr)
977 assert.Equal(t, 0, got.NextIndex)
978}
980// Test_continueFlow_branchNotRebasedOntoParent_errors covers the guard that
981// stops --continue from silently skipping a branch that was never rebased onto
982// its new parent (e.g. the user aborted the git rebase). It must error and
983// leave NextIndex untouched rather than advancing.
984func Test_continueFlow_branchNotRebasedOntoParent_errors(t *testing.T) {
985 git.InitGitRepoWithCommit(t)
987 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
988 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
989 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
990 }, "test-stack"))
991 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
993 // Reorder stalled at index 0: branchB should be rebased onto main first.
994 state := git.ReorderState{
995 NewOrder: []string{"branchB", "branchA"},
996 NextIndex: 0,
997 OldTips: map[string]string{"branchA": "aaaa", "branchB": "bbbb", "main": "0000"},
998 BaseBranch: "main",
999 OriginalBranch: "branchA",
1000 }
1001 require.NoError(t, git.WriteReorderState("test-stack", state))
1003 ctrl := gomock.NewController(t)
1004 mockGr := gittesting.NewMockGitRunner(ctrl)
1005 // branchB moved, but a non-zero `merge-base --is-ancestor` exit (returned
1006 // here as an error) means it did not land on main.
1007 gomock.InOrder(
1008 mockGr.EXPECT().Git("status", "--porcelain", "--untracked-files=no").Return("", nil),
1009 mockGr.EXPECT().Git("rev-parse", "branchB").Return("cccc\n", nil),
1010 mockGr.EXPECT().
1011 Git("merge-base", "--is-ancestor", "main", "branchB").
1012 Return("", fmt.Errorf("exit status 1")),
1013 )
1015 err := runReorderCmd(t, mockGr, "--continue")
1016 require.Error(t, err)
1017 assert.Contains(t, err.Error(), `branch "branchB" is not rebased onto "main"`)
1019 // The state must not have advanced past the unrebased branch.
1020 got, readErr := git.ReadReorderState("test-stack")
1021 require.NoError(t, readErr)
1022 assert.Equal(t, 0, got.NextIndex, "NextIndex must not advance when the branch is not rebased")
1023}
1025// After `git rebase --abort` the branch is back at its old tip. The new parent
1026// can still be an ancestor (always, for the base branch), so --continue must
1027// not advance on the ancestor check alone.
1028func Test_continueFlow_branchStillAtOldTip_errors(t *testing.T) {
1029 git.InitGitRepoWithCommit(t)
1031 require.NoError(t, git.CreateRefFiles(map[string]git.StackRef{
1032 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
1033 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
1034 }, "test-stack"))
1035 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
1037 state := git.ReorderState{
1038 NewOrder: []string{"branchB", "branchA"},
1039 NextIndex: 0,
1040 OldTips: map[string]string{"branchA": "aaaa", "branchB": "bbbb", "main": "0000"},
1041 BaseBranch: "main",
1042 OriginalBranch: "branchA",
1043 }
1044 require.NoError(t, git.WriteReorderState("test-stack", state))
1046 ctrl := gomock.NewController(t)
1047 mockGr := gittesting.NewMockGitRunner(ctrl)
1048 // No merge-base expectation: an unmoved tip must fail before the ancestor check.
1049 gomock.InOrder(
1050 mockGr.EXPECT().Git("status", "--porcelain", "--untracked-files=no").Return("", nil),
1051 mockGr.EXPECT().Git("rev-parse", "branchB").Return("bbbb\n", nil),
1052 )
1054 err := runReorderCmd(t, mockGr, "--continue")
1055 require.Error(t, err)
1056 assert.Contains(t, err.Error(), `branch "branchB" is not rebased onto "main"`)
1058 got, readErr := git.ReadReorderState("test-stack")
1059 require.NoError(t, readErr)
1060 assert.Equal(t, 0, got.NextIndex)
1061}
1063// Picks up where a user leaves off after resolving a conflict: the conflicted
1064// branch is already rebased by hand, and --continue must rebase the rest,
1065// write the new ref files, retarget every moved MR, and clear the state.
1066func Test_continueFlow_afterResolvedConflict_finishesReorder(t *testing.T) {
1067 git.InitGitRepoWithCommit(t)
1068 gr := git.StandardGitCommand{}
1069 gitExec(t, "branch", "-M", "main")
1070 gitExec(t, "remote", "add", "origin", "http://gitlab.com/stack_guy/stackproject.git")
1072 for _, b := range []string{"branchA", "branchB", "branchC"} {
1073 gitExec(t, "checkout", "-b", b)
1074 require.NoError(t, os.WriteFile("file"+b, []byte(b), 0o644))
1075 gitExec(t, "add", "file"+b)
1076 gitExec(t, "commit", "-m", "commit "+b)
1077 }
1078 gitExec(t, "checkout", "branchA")
1080 mr := func(iid string) string { return "http://gitlab.com/stack_guy/stackproject/-/merge_requests/" + iid }
1081 oldStack := git.Stack{Title: "test-stack", Refs: map[string]git.StackRef{
1082 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA", MR: mr("1")},
1083 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "ref-c", Branch: "branchB", MR: mr("2")},
1084 "ref-c": {SHA: "ref-c", Prev: "ref-b", Next: "", Branch: "branchC", MR: mr("3")},
1085 }}
1086 newStack := git.Stack{Title: "test-stack", Refs: map[string]git.StackRef{
1087 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-c", Branch: "branchA", MR: mr("1")},
1088 "ref-c": {SHA: "ref-c", Prev: "ref-a", Next: "ref-b", Branch: "branchC", MR: mr("3")},
1089 "ref-b": {SHA: "ref-b", Prev: "ref-c", Next: "", Branch: "branchB", MR: mr("2")},
1090 }}
1091 require.NoError(t, git.CreateRefFiles(oldStack.Refs, "test-stack"))
1092 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
1093 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
1095 // State as the conflict on branchC (index 1) left it, after the user
1096 // resolved it and finished `git rebase --continue`.
1097 state, err := prepareReorderState(gr, oldStack, newStack)
1098 require.NoError(t, err)
1099 gitExec(t, "checkout", "branchC")
1100 gitExec(t, "rebase", "--onto", "branchA", state.OldTips["branchB"])
1101 state.NextIndex = 1
1102 require.NoError(t, git.WriteReorderState("test-stack", state))
1104 testClient := gitlabtesting.NewTestClient(t)
1105 expectRetargets(t, testClient, map[string]retarget{
1106 "branchA": {iid: 1, target: "main"},
1107 "branchC": {iid: 3, target: "branchA"},
1108 "branchB": {iid: 2, target: "branchC"},
1109 })
1111 err = runReorderCmd(t, gr, "--continue", reorderFactoryOptions(t, testClient)...)
1112 require.NoError(t, err)
1114 assert.Equal(t, gitExec(t, "rev-parse", "branchA"), gitExec(t, "rev-parse", "branchC~1"), "branchC should sit on branchA")
1115 assert.Equal(t, gitExec(t, "rev-parse", "branchC"), gitExec(t, "rev-parse", "branchB~1"), "branchB should sit on branchC")
1117 currentBranch, err := git.CurrentBranch()
1118 require.NoError(t, err)
1119 assert.Equal(t, "branchA", currentBranch)
1121 onDisk, err := git.GatherStackRefs("test-stack")
1122 require.NoError(t, err)
1123 assert.Equal(t, newStack.Refs, onDisk.Refs)
1125 inProgress, err := git.ReorderInProgress("test-stack")
1126 require.NoError(t, err)
1127 assert.False(t, inProgress)
1128}
1130// Every rebase is done but the MR update failed, so --continue must only
1131// write the ref files and retarget the MRs, without running git.
1132func Test_continueFlow_rebasesDone_retriesMRUpdate(t *testing.T) {
1133 git.InitGitRepoWithCommit(t)
1134 gitExec(t, "remote", "add", "origin", "http://gitlab.com/stack_guy/stackproject.git")
1136 mr := func(iid string) string { return "http://gitlab.com/stack_guy/stackproject/-/merge_requests/" + iid }
1137 oldRefs := map[string]git.StackRef{
1138 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA", MR: mr("1")},
1139 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB", MR: mr("2")},
1140 }
1141 newRefs := map[string]git.StackRef{
1142 "ref-b": {SHA: "ref-b", Prev: "", Next: "ref-a", Branch: "branchB", MR: mr("2")},
1143 "ref-a": {SHA: "ref-a", Prev: "ref-b", Next: "", Branch: "branchA", MR: mr("1")},
1144 }
1145 require.NoError(t, git.CreateRefFiles(oldRefs, "test-stack"))
1146 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
1147 require.NoError(t, git.WriteReorderState("test-stack", git.ReorderState{
1148 NewOrder: []string{"branchB", "branchA"},
1149 NextIndex: 2,
1150 BaseBranch: "main",
1151 OriginalBranch: "branchA",
1152 OldRefs: oldRefs,
1153 NewRefs: newRefs,
1154 }))
1156 testClient := gitlabtesting.NewTestClient(t)
1157 expectRetargets(t, testClient, map[string]retarget{
1158 "branchB": {iid: 2, target: "main"},
1159 "branchA": {iid: 1, target: "branchB"},
1160 })
1162 // No expectations: the finish-only path must not run git.
1163 ctrl := gomock.NewController(t)
1164 mockGr := gittesting.NewMockGitRunner(ctrl)
1166 err := runReorderCmd(t, mockGr, "--continue", reorderFactoryOptions(t, testClient)...)
1167 require.NoError(t, err)
1169 onDisk, err := git.GatherStackRefs("test-stack")
1170 require.NoError(t, err)
1171 assert.Equal(t, newRefs, onDisk.Refs)
1173 inProgress, err := git.ReorderInProgress("test-stack")
1174 require.NoError(t, err)
1175 assert.False(t, inProgress)
1176}
1178// runReorderCmd runs `glab stack reorder <args>` through the real command and factory.
1179func runReorderCmd(t *testing.T, gr git.GitRunner, args string, opts ...cmdtest.FactoryOption) error {
1180 t.Helper()
1182 exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
1183 return NewCmdReorderStack(f, gr, nil)
1184 }, false, opts...)
1186 _, err := exec(args)
1187 return err
1188}
1190func Test_reorderCmd_noTTY_noArgs(t *testing.T) {
1191 git.InitGitRepoWithCommit(t)
1192 gitExec(t, "checkout", "-b", "branchA")
1193 oldRefs := map[string]git.StackRef{
1194 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
1195 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
1196 }
1197 require.NoError(t, git.CreateRefFiles(oldRefs, "test-stack"))
1198 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
1200 ctrl := gomock.NewController(t)
1201 mockGr := gittesting.NewMockGitRunner(ctrl)
1202 mockGr.EXPECT().Git("status", "--porcelain", "--untracked-files=no").Return("", nil)
1204 err := runReorderCmd(t, mockGr, "")
1205 require.Error(t, err)
1206 assert.Contains(t, err.Error(), "no TTY available: specify the branch order as arguments (glab stack reorder <branch>...)")
1207}
1209func Test_reorderCmd_argsWithFlags(t *testing.T) {
1210 ctrl := gomock.NewController(t)
1211 mockGr := gittesting.NewMockGitRunner(ctrl)
1213 err := runReorderCmd(t, mockGr, "--continue branchA branchB")
1214 require.Error(t, err)
1215 assert.Contains(t, err.Error(), "cannot specify branch order with --continue or --abort")
1217 err = runReorderCmd(t, mockGr, "--abort branchA branchB")
1218 require.Error(t, err)
1219 assert.Contains(t, err.Error(), "cannot specify branch order with --continue or --abort")
1220}
1222func Test_reorderCmd_positionalArgs_nonInteractive_reordersAndRetargets(t *testing.T) {
1223 git.InitGitRepoWithCommit(t)
1224 gr := git.StandardGitCommand{}
1225 gitExec(t, "branch", "-M", "main")
1226 gitExec(t, "remote", "add", "origin", "http://gitlab.com/stack_guy/stackproject.git")
1228 for _, b := range []string{"branchA", "branchB"} {
1229 gitExec(t, "checkout", "-b", b)
1230 require.NoError(t, os.WriteFile("file"+b, []byte(b), 0o644))
1231 gitExec(t, "add", "file"+b)
1232 gitExec(t, "commit", "-m", "commit "+b)
1233 }
1234 gitExec(t, "checkout", "branchA")
1236 mr := func(iid string) string { return "http://gitlab.com/stack_guy/stackproject/-/merge_requests/" + iid }
1237 oldRefs := map[string]git.StackRef{
1238 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA", MR: mr("1")},
1239 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB", MR: mr("2")},
1240 }
1241 require.NoError(t, git.CreateRefFiles(oldRefs, "test-stack"))
1242 require.NoError(t, git.AddStackBaseBranch("test-stack", "main"))
1243 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
1245 testClient := gitlabtesting.NewTestClient(t)
1246 expectRetargets(t, testClient, map[string]retarget{
1247 "branchB": {iid: 2, target: "main"},
1248 "branchA": {iid: 1, target: "branchB"},
1249 })
1251 err := runReorderCmd(t, gr, "branchB branchA", reorderFactoryOptions(t, testClient)...)
1252 require.NoError(t, err)
1254 assert.Equal(t, gitExec(t, "rev-parse", "main"), gitExec(t, "rev-parse", "branchB~1"), "branchB should sit on main")
1255 assert.Equal(t, gitExec(t, "rev-parse", "branchB"), gitExec(t, "rev-parse", "branchA~1"), "branchA should sit on branchB")
1257 currentBranch, err := git.CurrentBranch()
1258 require.NoError(t, err)
1259 assert.Equal(t, "branchA", currentBranch)
1261 expectedRefs := map[string]git.StackRef{
1262 "ref-b": {SHA: "ref-b", Prev: "", Next: "ref-a", Branch: "branchB", MR: mr("2")},
1263 "ref-a": {SHA: "ref-a", Prev: "ref-b", Next: "", Branch: "branchA", MR: mr("1")},
1264 }
1265 onDisk, err := git.GatherStackRefs("test-stack")
1266 require.NoError(t, err)
1267 assert.Equal(t, expectedRefs, onDisk.Refs)
1269 inProgress, err := git.ReorderInProgress("test-stack")
1270 require.NoError(t, err)
1271 assert.False(t, inProgress)
1272}
1274func Test_reorderCmd_positionalArgs_validationErrors(t *testing.T) {
1275 git.InitGitRepoWithCommit(t)
1276 gitExec(t, "checkout", "-b", "branchA")
1277 oldRefs := map[string]git.StackRef{
1278 "ref-a": {SHA: "ref-a", Prev: "", Next: "ref-b", Branch: "branchA"},
1279 "ref-b": {SHA: "ref-b", Prev: "ref-a", Next: "", Branch: "branchB"},
1280 }
1281 require.NoError(t, git.CreateRefFiles(oldRefs, "test-stack"))
1282 require.NoError(t, git.SetCurrentStackTitle("test-stack"))
1284 gr := git.StandardGitCommand{}
1286 t.Run("unknown branch errors", func(t *testing.T) {
1287 err := runReorderCmd(t, gr, "branchUnknown branchA")
1288 require.Error(t, err)
1289 assert.Contains(t, err.Error(), "Could not find stack ref for branch: branchUnknown")
1290 })
1292 t.Run("missing branch errors", func(t *testing.T) {
1293 err := runReorderCmd(t, gr, "branchA")
1294 require.Error(t, err)
1295 assert.Contains(t, err.Error(), "missing one or more refs from the reordered list")
1296 })
1298 t.Run("duplicate branch errors", func(t *testing.T) {
1299 err := runReorderCmd(t, gr, "branchA branchA")
1300 require.Error(t, err)
1301 assert.Contains(t, err.Error(), `duplicate branch "branchA" in reordered list`)
1302 })
1303}
Diagnostics8 git calls · 355 ms
CallStatusSizeTime0355 ms
discover200185 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=185 git.server.agent=git/2.56.g1891de4-Linux git.server.object_format=sha1 git.server.caps=agent ls-refs fetch server-option object-format git.server.fetch=shallow wait-for-done filter git.protocol.version=2 git.pkt.frames=9 git.pkt.data=7 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=185 git.pkt.payload.max=35
ls-refs20058 KiB · hit2 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 git.response.bytes=59849 git.response.cache=HIT git.response.duration_ms=2 git.protocol.version=2 git.pkt.frames=731 git.pkt.data=730 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=59849 git.pkt.payload.max=143 git.ls_refs.count=730 git.ls_refs.head=refs/heads/main
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · 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 · 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=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=44Open 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=fb03183b7909876778f740d196d7516811003517Open 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=3 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=8f3029a269217d94d12d0671e0490fe3d5506303Open pack map
fetchtree:0200201 B · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=342 git.response.bytes=201 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=8d987c4ced47a5d0625aad4a9e3c1ff8fbef16f4 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=201 git.pkt.payload.max=174 git.sideband.band1.bytes=174 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=174 git.pack.trailer=68708387661594a72de23ba4caed851864a875aaOpen pack map
fetch2007.9 KiB342 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=8091 git.response.cache=MISS git.response.duration_ms=342 git.fetch.wants=746edb3eadc5a536fb7778359b2b18fb5e4a3e0d 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=8091 git.pkt.payload.max=8064 git.sideband.band1.bytes=8064 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
- a5e25991addfa23e
- Request
- 24d9bfef…
- 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