package cmd

import (

"encoding/json"

"fmt"

"io"

"net/url"

"os"

"path/filepath"

"testing"

"github.com/cli/go-gh/v2/pkg/api"

"github.com/github/gh-stack/internal/config"

"github.com/github/gh-stack/internal/git"

"github.com/github/gh-stack/internal/github"

"github.com/github/gh-stack/internal/modify"

"github.com/github/gh-stack/internal/stack"

"github.com/github/gh-stack/internal/tui/submitview"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

)

func TestGeneratePRBody(t *testing.T) {

tests := []struct {

name string

commitBody string

templateContent string

wantContains []string

wantNotContains []string

}{

{

name: "empty commit body no template",

commitBody: "",

wantContains: []string{

"GitHub Stacks CLI",

feedbackURL,

"<sub>",

},

},

{

name: "with commit body no template",

commitBody: "This is a detailed description\nof the change.",

wantContains: []string{

"This is a detailed description\nof the change.",

"GitHub Stacks CLI",

"<sub>",

},

},

{

name: "with template",

commitBody: "some commit body",

templateContent: "## Description\n\nFill in details.",

wantContains: []string{

"## Description",

"Fill in details.",

},

wantNotContains: []string{

"GitHub Stacks CLI",

feedbackURL,

"some commit body",

},

},

{

name: "template replaces footer",

templateContent: "Template body only",

wantContains: []string{"Template body only"},

wantNotContains: []string{"<sub>"},

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

got := generatePRBody(tt.commitBody, tt.templateContent)

for _, want := range tt.wantContains {

assert.Contains(t, got, want)

}

for _, notWant := range tt.wantNotContains {

assert.NotContains(t, got, notWant)

}

})

}

}

// newSubmitMock creates a MockOps pre-configured for submit tests.

func newSubmitMock(tmpDir string, currentBranch string) *git.MockOps {

return &git.MockOps{

GitDirFn: func() (string, error) { return tmpDir, nil },

RootDirFn: func() (string, error) { return tmpDir, nil },

CurrentBranchFn: func() (string, error) { return currentBranch, nil },

ResolveRemoteFn: func(string) (string, error) { return "origin", nil },

PushFn: func(string, []string, bool, bool) error { return nil },

}

}

func TestSubmit_CreatesPRsAndStack(t *testing.T) {

s := stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1"},

{Branch: "b2"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var pushCalls []pushCall

var createdPRs []string

mock := newSubmitMock(tmpDir, "b1")

mock.PushFn = func(remote string, branches []string, force, atomic bool) error {

pushCalls = append(pushCalls, pushCall{remote, branches, force, atomic})

return nil

}

mock.LogRangeFn = func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{{Subject: "commit for " + head}}, nil

}

restore := git.SetOps(mock)

defer restore()

prCounter := 100

cfg, _, errR := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

FindPRForBranchFn: func(branch string) (*github.PullRequest, error) {

return nil, nil // No existing PR

},

CreatePRFn: func(base, head, title, body string, draft bool) (*github.PullRequest, error) {

createdPRs = append(createdPRs, head)

prCounter++

return &github.PullRequest{

Number: prCounter,

ID: fmt.Sprintf("PR_%d", prCounter),

URL: fmt.Sprintf("https://github.com/owner/repo/pull/%d", prCounter),

}, nil

},

CreateStackFn: func(prNumbers []int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: 42, Number: 42}, nil

},

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.NoError(t, err)

// Branches should be pushed (sequentially, one per branch)

require.Len(t, pushCalls, 2)

assert.Equal(t, "origin", pushCalls[0].remote)

assert.Equal(t, []string{"b1"}, pushCalls[0].branches)

assert.Equal(t, []string{"b2"}, pushCalls[1].branches)

// PRs should be created

assert.Equal(t, []string{"b1", "b2"}, createdPRs)

// Stack should be created

assert.Contains(t, output, "Stack created on GitHub with 2 PRs")

assert.Contains(t, output, "Pushed and synced 2 branches")

}

func TestSubmit_DefaultDraft(t *testing.T) {

s := stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var createdDraft bool

mock := newSubmitMock(tmpDir, "b1")

mock.PushFn = func(string, []string, bool, bool) error { return nil }

mock.LogRangeFn = func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{{Subject: "commit for " + head}}, nil

}

restore := git.SetOps(mock)

defer restore()

cfg, _, _ := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

ListStacksFn: func() ([]github.RemoteStack, error) { return nil, nil },

FindPRForBranchFn: func(string) (*github.PullRequest, error) { return nil, nil },

CreatePRFn: func(base, head, title, body string, draft bool) (*github.PullRequest, error) {

createdDraft = draft

return &github.PullRequest{Number: 1, ID: "PR_1", URL: "https://github.com/o/r/pull/1"}, nil

},

CreateStackFn: func([]int) (*github.RemoteStack, error) { return &github.RemoteStack{ID: 1, Number: 1}, nil },

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

assert.NoError(t, err)

assert.True(t, createdDraft, "PRs should be created as drafts by default")

}

func TestSubmit_OpenFlag(t *testing.T) {

s := stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var createdDraft bool

mock := newSubmitMock(tmpDir, "b1")

mock.PushFn = func(string, []string, bool, bool) error { return nil }

mock.LogRangeFn = func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{{Subject: "commit for " + head}}, nil

}

restore := git.SetOps(mock)

defer restore()

cfg, _, _ := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

ListStacksFn: func() ([]github.RemoteStack, error) { return nil, nil },

FindPRForBranchFn: func(string) (*github.PullRequest, error) { return nil, nil },

CreatePRFn: func(base, head, title, body string, draft bool) (*github.PullRequest, error) {

createdDraft = draft

return &github.PullRequest{Number: 1, ID: "PR_1", URL: "https://github.com/o/r/pull/1"}, nil

},

CreateStackFn: func([]int) (*github.RemoteStack, error) { return &github.RemoteStack{ID: 1, Number: 1}, nil },

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto", "--open"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

assert.NoError(t, err)

assert.False(t, createdDraft, "PRs should not be created as drafts when --open is set")

}

func TestSubmit_OpenFlag_ConvertsDraftPRs(t *testing.T) {

s := stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10, ID: "PR_10"}},

{Branch: "b2"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var markedReady []string

mock := newSubmitMock(tmpDir, "b1")

mock.PushFn = func(string, []string, bool, bool) error { return nil }

mock.LogRangeFn = func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{{Subject: "commit for " + head}}, nil

}

restore := git.SetOps(mock)

defer restore()

cfg, _, errR := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

ListStacksFn: func() ([]github.RemoteStack, error) { return nil, nil },

FindPRForBranchFn: func(branch string) (*github.PullRequest, error) {

switch branch {

case "b1":

return &github.PullRequest{

Number: 10, ID: "PR_10", HeadRefName: "b1", BaseRefName: "main",

IsDraft: true, URL: "https://github.com/o/r/pull/10",

}, nil

}

return nil, nil

},

CreatePRFn: func(base, head, title, body string, draft bool) (*github.PullRequest, error) {

return &github.PullRequest{

Number: 11, ID: "PR_11", URL: "https://github.com/o/r/pull/11",

}, nil

},

MarkPRReadyForReviewFn: func(prID string) error {

markedReady = append(markedReady, prID)

return nil

},

CreateStackFn: func([]int) (*github.RemoteStack, error) { return &github.RemoteStack{ID: 1, Number: 1}, nil },

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto", "--open"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.NoError(t, err)

assert.Equal(t, []string{"PR_10"}, markedReady, "existing draft PR should be marked ready")

assert.Contains(t, output, "Marked PR")

}

func TestSubmit_PushFailure(t *testing.T) {

s := stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

mock := newSubmitMock(tmpDir, "b1")

mock.PushFn = func(string, []string, bool, bool) error {

return fmt.Errorf("remote rejected")

}

restore := git.SetOps(mock)

defer restore()

cfg, _, errR := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.ErrorIs(t, err, ErrSilent)

assert.Contains(t, output, "failed to push")

}

func TestSubmit_SkipsMergedBranches(t *testing.T) {

s := stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1, Merged: true}},

{Branch: "b2"},

{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 3, Merged: true}},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var pushCalls []pushCall

mock := newSubmitMock(tmpDir, "b2")

mock.PushFn = func(remote string, branches []string, force, atomic bool) error {

pushCalls = append(pushCalls, pushCall{remote, branches, force, atomic})

return nil

}

restore := git.SetOps(mock)

defer restore()

cfg, _, errR := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

FindPRForBranchFn: func(branch string) (*github.PullRequest, error) {

// Only return an OPEN PR for the active branch (b2).

// Merged branches (b1, b3) should have no open PR.

if branch == "b2" {

return &github.PullRequest{Number: 2, URL: "https://github.com/owner/repo/pull/2", State: "OPEN"}, nil

}

return nil, nil

},

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

cfg.Err.Close()

_, _ = io.ReadAll(errR)

assert.NoError(t, err)

require.Len(t, pushCalls, 1)

assert.Equal(t, []string{"b2"}, pushCalls[0].branches)

}

// TestSubmit_ForksWhenRemoteStackFullyMerged covers the case where every PR

// officially part of the stack on GitHub has merged and the user has added new

// branches on top. Submit should lift the new branches into a fresh stack rooted

// at the trunk and create a new stack on GitHub, leaving the merged stack alone.

func TestSubmit_ForksWhenRemoteStackFullyMerged(t *testing.T) {

tests := []struct {

name string

branchesExist bool // do the merged branches still exist locally?

wantStackCount int

}{

{name: "removes old stack when merged branches are gone", branchesExist: false, wantStackCount: 1},

{name: "keeps old stack when merged branches still exist", branchesExist: true, wantStackCount: 2},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

s := stack.Stack{

ID: "42",

Number: 42,

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1, Merged: true}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 2, Merged: true}},

{Branch: "b3"},

{Branch: "b4"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var pushCalls []pushCall

var createdPRs []string

var createStackPRs []int

mock := newSubmitMock(tmpDir, "b4")

mock.PushFn = func(remote string, branches []string, force, atomic bool) error {

pushCalls = append(pushCalls, pushCall{remote, branches, force, atomic})

return nil

}

mock.LogRangeFn = func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{{Subject: "commit for " + head}}, nil

}

mock.MergeBaseFn = func(a, b string) (string, error) { return "basesha", nil }

mock.RevParseFn = func(ref string) (string, error) { return "sha-" + ref, nil }

mock.BranchExistsFn = func(string) bool { return tt.branchesExist }

restore := git.SetOps(mock)

defer restore()

prCounter := 100

cfg, _, errR := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

ListStacksFn: func() ([]github.RemoteStack, error) {

return []github.RemoteStack{{ID: 42, PullRequests: []int{1, 2}}}, nil

},

FindPRByNumberFn: func(n int) (*github.PullRequest, error) {

switch n {

case 1:

return &github.PullRequest{Number: 1, HeadRefName: "b1", State: "MERGED", Merged: true}, nil

case 2:

return &github.PullRequest{Number: 2, HeadRefName: "b2", State: "MERGED", Merged: true}, nil

}

return &github.PullRequest{Number: n, State: "OPEN"}, nil

},

FindPRForBranchFn: func(string) (*github.PullRequest, error) { return nil, nil },

CreatePRFn: func(base, head, title, body string, draft bool) (*github.PullRequest, error) {

createdPRs = append(createdPRs, head)

prCounter++

return &github.PullRequest{

Number: prCounter,

ID: fmt.Sprintf("PR_%d", prCounter),

URL: fmt.Sprintf("https://github.com/o/r/pull/%d", prCounter),

HeadRefName: head,

}, nil

},

CreateStackFn: func(prNumbers []int) (*github.RemoteStack, error) {

createStackPRs = prNumbers

return &github.RemoteStack{ID: 99, Number: 99}, nil

},

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

require.NoError(t, err)

// Only the new branches are pushed; merged ones are left behind.

require.Len(t, pushCalls, 2)

assert.Equal(t, []string{"b3"}, pushCalls[0].branches)

assert.Equal(t, []string{"b4"}, pushCalls[1].branches)

// Fork messaging.

assert.Contains(t, output, "Every PR in this stack has already been merged")

assert.Contains(t, output, "starting a new stack")

// PRs are created for the new branches and grouped into a new stack.

assert.Equal(t, []string{"b3", "b4"}, createdPRs)

assert.Equal(t, []int{101, 102}, createStackPRs)

// The local stack file is split: the new branches form their own

// stack rooted at the trunk with the freshly created remote ID.

reloaded, err := stack.Load(tmpDir)

require.NoError(t, err)

require.Len(t, reloaded.Stacks, tt.wantStackCount)

forked := reloaded.FindAllStacksForBranch("b4")

require.Len(t, forked, 1)

assert.Equal(t, []string{"b3", "b4"}, forked[0].BranchNames())

assert.Equal(t, "99", forked[0].ID)

assert.Equal(t, "main", forked[0].Trunk.Branch)

oldStack := reloaded.FindAllStacksForBranch("b1")

if tt.branchesExist {

require.Len(t, oldStack, 1)

assert.Equal(t, []string{"b1", "b2"}, oldStack[0].BranchNames())

assert.Equal(t, "42", oldStack[0].ID)

} else {

assert.Empty(t, oldStack)

}

})

}

}

// TestSubmit_NoForkWhenRemoteStackHasOpenPR verifies that a normal partially

// merged stack (the remote stack still has an open PR) is NOT forked — that is

// the everyday bottom-up merge flow and must keep working as before.

func TestSubmit_NoForkWhenRemoteStackHasOpenPR(t *testing.T) {

s := stack.Stack{

ID: "42",

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1, Merged: true}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 2, Merged: true}},

{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 3}},

{Branch: "b4"},

},

}

tmpDir := t.TempDir()

writeStackFile(t, tmpDir, s)

var pushCalls []pushCall

mock := newSubmitMock(tmpDir, "b4")

mock.PushFn = func(remote string, branches []string, force, atomic bool) error {

pushCalls = append(pushCalls, pushCall{remote, branches, force, atomic})

return nil

}

mock.LogRangeFn = func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{{Subject: "commit for " + head}}, nil

}

mock.MergeBaseFn = func(a, b string) (string, error) { return "basesha", nil }

mock.RevParseFn = func(ref string) (string, error) { return "sha-" + ref, nil }

mock.BranchExistsFn = func(string) bool { return true }

restore := git.SetOps(mock)

defer restore()

prCounter := 100

cfg, _, errR := config.NewTestConfig()

cfg.GitHubClientOverride = &github.MockClient{

ListStacksFn: func() ([]github.RemoteStack, error) {

return []github.RemoteStack{{ID: 42, Number: 42, PullRequests: []int{1, 2, 3}}}, nil

},

FindPRByNumberFn: func(n int) (*github.PullRequest, error) {

switch n {

case 1:

return &github.PullRequest{Number: 1, HeadRefName: "b1", State: "MERGED", Merged: true}, nil

case 2:

return &github.PullRequest{Number: 2, HeadRefName: "b2", State: "MERGED", Merged: true}, nil

case 3:

return &github.PullRequest{Number: 3, HeadRefName: "b3", State: "OPEN"}, nil

}

return &github.PullRequest{Number: n, State: "OPEN"}, nil

},

FindPRForBranchFn: func(string) (*github.PullRequest, error) { return nil, nil },

CreatePRFn: func(base, head, title, body string, draft bool) (*github.PullRequest, error) {

prCounter++

return &github.PullRequest{

Number: prCounter,

ID: fmt.Sprintf("PR_%d", prCounter),

URL: fmt.Sprintf("https://github.com/o/r/pull/%d", prCounter),

HeadRefName: head,

}, nil

},

GetStackFn: func(int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: 42, Number: 42, PullRequests: []int{1, 2, 3}}, nil

},

AddToStackFn: func(int, []int) (*github.RemoteStack, error) {

// Merged-and-deleted base branches break the chain on GitHub.

return nil, &api.HTTPError{

StatusCode: 422,

Message: "Pull requests must form a stack, where each PR's base ref is the previous PR's head ref",

RequestURL: &url.URL{Path: "/repos/o/r/stacks/42/add"},

}

},

}

cmd := SubmitCmd(cfg)

cmd.SetArgs([]string{"--auto"})

cmd.SetOut(io.Discard)

cmd.SetErr(io.Discard)

err := cmd.Execute()

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

require.NoError(t, err)

// No fork happened.

assert.NotContains(t, output, "starting a new stack")

// The broken-chain update is explained calmly, not as a scary failure.

assert.Contains(t, output, "Merged PRs have left the stack")

assert.NotContains(t, output, "Failed to update stack")

// The local stack file is untouched: still a single stack with all branches.

reloaded, err := stack.Load(tmpDir)

require.NoError(t, err)

require.Len(t, reloaded.Stacks, 1)

assert.Equal(t, []string{"b1", "b2", "b3", "b4"}, reloaded.Stacks[0].BranchNames())

}

// TestUpdateStack_BrokenChainAfterMerge verifies the "must form a stack" 422 is

// reported calmly when merged branches are present, but still warns otherwise.

func TestUpdateStack_BrokenChainAfterMerge(t *testing.T) {

mustFormErr := func() error {

return &api.HTTPError{

StatusCode: 422,

Message: "Pull requests must form a stack, where each PR's base ref is the previous PR's head ref",

RequestURL: &url.URL{Path: "/repos/o/r/stacks/42/add"},

}

}

t.Run("merged branches present is reported calmly", func(t *testing.T) {

s := &stack.Stack{

ID: "42",

Number: 42,

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1, Merged: true}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 2}},

{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 3}},

},

}

mock := &github.MockClient{

GetStackFn: func(int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: 42, Number: 42, PullRequests: []int{1, 2}}, nil

},

AddToStackFn: func(int, []int) (*github.RemoteStack, error) { return nil, mustFormErr() },

}

cfg, _, errR := config.NewTestConfig()

updateStack(cfg, mock, s, []int{1, 2, 3})

cfg.Err.Close()

out, _ := io.ReadAll(errR)

output := string(out)

assert.Contains(t, output, "Merged PRs have left the stack")

assert.NotContains(t, output, "Failed to update stack")

})

t.Run("no merged branches still warns", func(t *testing.T) {

s := &stack.Stack{

ID: "42",

Number: 42,

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 2}},

},

}

mock := &github.MockClient{

GetStackFn: func(int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: 42, Number: 42, PullRequests: []int{1}}, nil

},

AddToStackFn: func(int, []int) (*github.RemoteStack, error) { return nil, mustFormErr() },

}

cfg, _, errR := config.NewTestConfig()

updateStack(cfg, mock, s, []int{1, 2})

cfg.Err.Close()

out, _ := io.ReadAll(errR)

output := string(out)

assert.Contains(t, output, "Failed to update stack")

})

}

func TestSubmit_DefaultPRTitleBody(t *testing.T) {

t.Run("single_commit", func(t *testing.T) {

restore := git.SetOps(&git.MockOps{

LogRangeFn: func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{

{Subject: "Add login page", Body: "Implements the OAuth flow"},

}, nil

},

})

defer restore()

title, body := defaultPRTitleBody("main", "feat-login")

assert.Equal(t, "Add login page", title)

assert.Equal(t, "Implements the OAuth flow", body)

})

t.Run("multiple_commits", func(t *testing.T) {

restore := git.SetOps(&git.MockOps{

LogRangeFn: func(base, head string) ([]git.CommitInfo, error) {

return []git.CommitInfo{

{Subject: "First commit"},

{Subject: "Second commit"},

}, nil

},

})

defer restore()

title, body := defaultPRTitleBody("main", "my-feature")

assert.Equal(t, "my feature", title)

assert.Equal(t, "", body)

})

}

func TestSubmit_Humanize(t *testing.T) {

tests := []struct {

input string

want string

}{

{"my-branch", "my branch"},

{"my_branch", "my branch"},

{"nobranch", "nobranch"},

}

for _, tt := range tests {

t.Run(tt.input, func(t *testing.T) {

assert.Equal(t, tt.want, humanize(tt.input))

})

}

}

func TestSyncStack_NewStack_CreateSuccess(t *testing.T) {

s := &stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

},

}

var gotNumbers []int

mock := &github.MockClient{

CreateStackFn: func(prNumbers []int) (*github.RemoteStack, error) {

gotNumbers = prNumbers

return &github.RemoteStack{ID: 42, Number: 42}, nil

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.Equal(t, []int{10, 11}, gotNumbers)

assert.Equal(t, "42", s.ID)

assert.Contains(t, output, "Stack created on GitHub with 2 PRs")

}

func TestSyncStack_ExistingStack_UpdateSuccess(t *testing.T) {

s := &stack.Stack{

ID: "99",

Number: 99,

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 12}},

},

}

var gotStackNumber int

var gotNumbers []int

createCalled := false

mock := &github.MockClient{

CreateStackFn: func([]int) (*github.RemoteStack, error) {

createCalled = true

return &github.RemoteStack{ID: 0, Number: 0}, nil

},

GetStackFn: func(stackNumber int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: stackNumber, Number: stackNumber, PullRequests: []int{10, 11}}, nil

},

AddToStackFn: func(stackNumber int, prNumbers []int) (*github.RemoteStack, error) {

gotStackNumber = stackNumber

gotNumbers = prNumbers

return &github.RemoteStack{ID: 99, Number: 99, PullRequests: []int{10, 11, 12}}, nil

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.False(t, createCalled, "CreateStack should not be called when s.ID is set")

assert.Equal(t, 99, gotStackNumber)

assert.Equal(t, []int{12}, gotNumbers)

assert.Contains(t, output, "Stack updated on GitHub with 3 PRs")

}

func TestSyncStack_ExistingStack_UpdateFails(t *testing.T) {

s := &stack.Stack{

ID: "99",

Number: 99,

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

},

}

mock := &github.MockClient{

GetStackFn: func(int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: 99, Number: 99, PullRequests: []int{10}}, nil

},

AddToStackFn: func(int, []int) (*github.RemoteStack, error) {

return nil, &api.HTTPError{

StatusCode: 422,

Message: "Validation failed",

RequestURL: &url.URL{Path: "/repos/o/r/stacks/99/add"},

}

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.Contains(t, output, "Failed to update stack")

}

func TestSyncStack_ExistingStack_Update404(t *testing.T) {

s := &stack.Stack{

ID: "99",

Number: 99,

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

},

}

var createCalled bool

mock := &github.MockClient{

GetStackFn: func(int) (*github.RemoteStack, error) {

return &github.RemoteStack{ID: 99, Number: 99, PullRequests: []int{10}}, nil

},

AddToStackFn: func(int, []int) (*github.RemoteStack, error) {

return nil, &api.HTTPError{

StatusCode: 404,

Message: "Not Found",

RequestURL: &url.URL{Path: "/repos/o/r/stacks/99/add"},

}

},

CreateStackFn: func(prNumbers []int) (*github.RemoteStack, error) {

createCalled = true

return &github.RemoteStack{ID: 55, Number: 55}, nil

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.True(t, createCalled, "should fall through to CreateStack after 404")

assert.Equal(t, "55", s.ID, "should set new stack ID from create response")

assert.Contains(t, output, "Stack created on GitHub with 2 PRs")

}

func TestSyncStack_AlreadyStacked_OurStack(t *testing.T) {

// All our PRs are listed as "already stacked" — this is our stack, show up-to-date.

s := &stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

},

}

mock := &github.MockClient{

CreateStackFn: func([]int) (*github.RemoteStack, error) {

return nil, &api.HTTPError{

StatusCode: 422,

Message: "Pull requests #10, #11 are already stacked",

RequestURL: &url.URL{Path: "/repos/o/r/stacks"},

}

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.Contains(t, output, "Stack with 2 PRs is up to date")

assert.NotContains(t, output, "different stack")

}

func TestSyncStack_AlreadyStacked_DifferentStack(t *testing.T) {

// Only a subset of our PRs are listed — they're in a different stack.

s := &stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 12}},

},

}

mock := &github.MockClient{

CreateStackFn: func([]int) (*github.RemoteStack, error) {

return nil, &api.HTTPError{

StatusCode: 422,

Message: "Pull requests #10, #11 are already stacked",

RequestURL: &url.URL{Path: "/repos/o/r/stacks"},

}

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.Contains(t, output, "different stack")

assert.NotContains(t, output, "up to date")

}

func TestSyncStack_AdoptsExistingRemoteStack_ExactMatch(t *testing.T) {

// The stack exists on GitHub but isn't recorded locally (s.ID == "").

// All local PRs match the remote stack exactly — adopt the ID without

// creating or updating anything.

s := &stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

},

}

var createCalled, updateCalled bool

mock := &github.MockClient{

ListStacksFn: func() ([]github.RemoteStack, error) {

return []github.RemoteStack{{ID: 77, Number: 77, PullRequests: []int{10, 11}}}, nil

},

CreateStackFn: func([]int) (*github.RemoteStack, error) {

createCalled = true

return &github.RemoteStack{ID: 0, Number: 0}, nil

},

AddToStackFn: func(int, []int) (*github.RemoteStack, error) {

updateCalled = true

return &github.RemoteStack{ID: 77, Number: 77, PullRequests: []int{10, 11}}, nil

},

}

cfg, _, errR := config.NewTestConfig()

syncStack(cfg, mock, s)

cfg.Err.Close()

errOut, _ := io.ReadAll(errR)

output := string(errOut)

assert.False(t, createCalled, "should not create when the stack already exists on GitHub")

assert.False(t, updateCalled, "should not update when local matches remote exactly")

assert.Equal(t, "77", s.ID, "should adopt the remote stack ID into local tracking")

assert.Contains(t, output, "Linked to the existing stack on GitHub")

assert.Contains(t, output, "up to date")

}

func TestSyncStack_AdoptsExistingRemoteStack_AddsNewPR(t *testing.T) {

// Two of our three PRs already form a remote stack; the third was added

// locally on top. Adopt the remote ID and update the stack to include the

// new PR at the top.

s := &stack.Stack{

Trunk: stack.BranchRef{Branch: "main"},

Branches: []stack.BranchRef{

{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 10}},

{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 11}},

{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 12}},

},