github__gh-stack/cmd/view_test.go

package cmd

import (
	"encoding/json"
	"io"
	"os"
	"path/filepath"
	"testing"
	"time"

	"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/stack"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestTimeAgo(t *testing.T) {
	tests := []struct {
		name     string
		duration time.Duration
		want     string
	}{
		{"seconds", 30 * time.Second, "30 seconds ago"},
		{"one second", 1 * time.Second, "1 second ago"},
		{"minutes", 5 * time.Minute, "5 minutes ago"},
		{"one minute", 1 * time.Minute, "1 minute ago"},
		{"hours", 3 * time.Hour, "3 hours ago"},
		{"one hour", 1 * time.Hour, "1 hour ago"},
		{"days", 2 * 24 * time.Hour, "2 days ago"},
		{"one day", 24 * time.Hour, "1 day ago"},
		{"months", 60 * 24 * time.Hour, "2 months ago"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := timeAgo(time.Now().Add(-tt.duration))
			assert.Equal(t, tt.want, result)
		})
	}
}

func TestViewJSON(t *testing.T) {
	git.SetOps(&git.MockOps{
		IsAncestorFn: func(ancestor, descendant string) (bool, error) {
			return true, nil // all branches are linear
		},
	})

	tests := []struct {
		name          string
		stack         *stack.Stack
		currentBranch string
		wantTrunk     string
		wantBranches  int
		wantCurrent   string
	}{
		{
			name: "basic stack with PRs",
			stack: &stack.Stack{
				Trunk: stack.BranchRef{Branch: "main", Head: "aaa"},
				Branches: []stack.BranchRef{
					{
						Branch:      "feat/01",
						Head:        "bbb",
						Base:        "aaa",
						PullRequest: &stack.PullRequestRef{Number: 42, URL: "https://github.com/o/r/pull/42"},
					},
					{
						Branch:      "feat/02",
						Head:        "ccc",
						Base:        "bbb",
						PullRequest: &stack.PullRequestRef{Number: 43, URL: "https://github.com/o/r/pull/43"},
					},
				},
			},
			currentBranch: "feat/02",
			wantTrunk:     "main",
			wantBranches:  2,
			wantCurrent:   "feat/02",
		},
		{
			name: "stack with merged branch",
			stack: &stack.Stack{
				Trunk: stack.BranchRef{Branch: "main", Head: "aaa"},
				Branches: []stack.BranchRef{
					{
						Branch:      "layer-1",
						Head:        "bbb",
						Base:        "aaa",
						PullRequest: &stack.PullRequestRef{Number: 10, Merged: true},
					},
					{
						Branch: "layer-2",
						Head:   "ccc",
						Base:   "bbb",
					},
				},
			},
			currentBranch: "layer-2",
			wantTrunk:     "main",
			wantBranches:  2,
			wantCurrent:   "layer-2",
		},
		{
			name: "empty stack",
			stack: &stack.Stack{
				Trunk:    stack.BranchRef{Branch: "main"},
				Branches: []stack.BranchRef{},
			},
			currentBranch: "main",
			wantTrunk:     "main",
			wantBranches:  0,
			wantCurrent:   "main",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cfg, outR, _ := config.NewTestConfig()
			defer outR.Close()

			err := viewJSON(cfg, tt.stack, tt.currentBranch)
			require.NoError(t, err)
			cfg.Out.Close()

			raw, err := io.ReadAll(outR)
			require.NoError(t, err)

			var got viewJSONOutput
			err = json.Unmarshal(raw, &got)
			require.NoError(t, err, "output should be valid JSON: %s", string(raw))

			assert.Equal(t, tt.wantTrunk, got.Trunk)
			assert.Equal(t, tt.wantCurrent, got.CurrentBranch)
			assert.Len(t, got.Branches, tt.wantBranches)
		})
	}
}

func TestViewJSON_BranchFields(t *testing.T) {
	git.SetOps(&git.MockOps{
		IsAncestorFn: func(ancestor, descendant string) (bool, error) {
			// feat/02 needs rebase
			if descendant == "feat/02" {
				return false, nil
			}
			return true, nil
		},
	})

	s := &stack.Stack{
		Trunk: stack.BranchRef{Branch: "main", Head: "aaa111"},
		Branches: []stack.BranchRef{
			{
				Branch:      "feat/01",
				Head:        "bbb222",
				Base:        "aaa111",
				PullRequest: &stack.PullRequestRef{Number: 42, URL: "https://github.com/o/r/pull/42", Merged: true},
			},
			{
				Branch:      "feat/02",
				Head:        "ccc333",
				Base:        "bbb222",
				PullRequest: &stack.PullRequestRef{Number: 43, URL: "https://github.com/o/r/pull/43"},
			},
		},
	}

	cfg, outR, _ := config.NewTestConfig()
	defer outR.Close()

	err := viewJSON(cfg, s, "feat/02")
	require.NoError(t, err)
	cfg.Out.Close()

	raw, err := io.ReadAll(outR)
	require.NoError(t, err)

	var got viewJSONOutput
	require.NoError(t, json.Unmarshal(raw, &got))

	// First branch: merged
	b0 := got.Branches[0]
	assert.Equal(t, "feat/01", b0.Name)
	assert.Equal(t, "bbb222", b0.Head)
	assert.Equal(t, "aaa111", b0.Base)
	assert.False(t, b0.IsCurrent)
	assert.True(t, b0.IsMerged)
	assert.False(t, b0.NeedsRebase, "merged branches should not need rebase")
	require.NotNil(t, b0.PR)
	assert.Equal(t, 42, b0.PR.Number)
	assert.Equal(t, "MERGED", b0.PR.State)
	assert.Equal(t, "https://github.com/o/r/pull/42", b0.PR.URL)

	// Second branch: current, needs rebase
	b1 := got.Branches[1]
	assert.Equal(t, "feat/02", b1.Name)
	assert.True(t, b1.IsCurrent)
	assert.False(t, b1.IsMerged)
	assert.True(t, b1.NeedsRebase)
	require.NotNil(t, b1.PR)
	assert.Equal(t, 43, b1.PR.Number)
	assert.Equal(t, "OPEN", b1.PR.State)
}

// TestViewShort_ActiveStack verifies that --short output contains all branch
// names and the trunk for an active stack.
func TestViewShort_ActiveStack(t *testing.T) {
	s := stack.Stack{
		Trunk: stack.BranchRef{Branch: "main"},
		Branches: []stack.BranchRef{
			{Branch: "b1"},
			{Branch: "b2"},
			{Branch: "b3"},
		},
	}

	tmpDir := t.TempDir()
	writeStackFile(t, tmpDir, s)

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "b2", nil },
		IsAncestorFn:    func(string, string) (bool, error) { return true, nil },
		RevParseFn:      func(ref string) (string, error) { return "sha-" + ref, nil },
	})
	defer restore()

	cfg, outR, _ := config.NewTestConfig()
	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--short"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Out.Close()
	raw, _ := io.ReadAll(outR)
	output := string(raw)

	assert.NoError(t, err)
	assert.Contains(t, output, "b1")
	assert.Contains(t, output, "b2")
	assert.Contains(t, output, "b3")
	assert.Contains(t, output, "main")
}

func TestShortPRSuffix_PlainURLFallback(t *testing.T) {
	t.Setenv("GH_STACK_HYPERLINKS", "0")

	cfg, outR, errR := config.NewTestConfig()
	defer cfg.Out.Close()
	defer cfg.Err.Close()
	defer outR.Close()
	defer errR.Close()

	b := stack.BranchRef{
		PullRequest: &stack.PullRequestRef{
			Number: 42,
			URL:    "https://github.com/o/r/pull/42",
		},
	}

	suffix := shortPRSuffix(cfg, b, "", "", "")
	assert.Equal(t, " #42 (https://github.com/o/r/pull/42)", suffix)
	assert.NotContains(t, suffix, "\x1b]8")
}

// TestViewShort_FullyMergedStack verifies that --short output shows merged
// branches correctly when all branches in the stack are merged.
func TestViewShort_FullyMergedStack(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", PullRequest: &stack.PullRequestRef{Number: 2, Merged: true}},
		},
	}

	tmpDir := t.TempDir()
	writeStackFile(t, tmpDir, s)

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "main", nil },
		IsAncestorFn:    func(string, string) (bool, error) { return true, nil },
		RevParseFn:      func(ref string) (string, error) { return "sha-" + ref, nil },
	})
	defer restore()

	cfg, outR, _ := config.NewTestConfig()
	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--short"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Out.Close()
	raw, _ := io.ReadAll(outR)
	output := string(raw)

	assert.NoError(t, err)
	assert.Contains(t, output, "b1")
	assert.Contains(t, output, "b2")
}

// TestViewShort_QueuedStack verifies that --short output shows queued
// branches with a "queued" separator and the ◎ icon.
func TestViewShort_QueuedStack(t *testing.T) {
	s := stack.Stack{
		Trunk: stack.BranchRef{Branch: "main"},
		Branches: []stack.BranchRef{
			{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1}},
			{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 2}},
			{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 3}},
		},
	}

	tmpDir := t.TempDir()
	writeStackFile(t, tmpDir, s)

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "b3", nil },
		IsAncestorFn:    func(string, string) (bool, error) { return true, nil },
		RevParseFn:      func(ref string) (string, error) { return "sha-" + ref, nil },
	})
	defer restore()

	// Mock GitHub client to return b1 as queued (MergeQueueEntry set)
	cfg, outR, _ := config.NewTestConfig()
	cfg.GitHubClientOverride = &github.MockClient{
		FindPRByNumberFn: func(number int) (*github.PullRequest, error) {
			switch number {
			case 1:
				return &github.PullRequest{
					Number:          1,
					ID:              "PR_1",
					State:           "OPEN",
					MergeQueueEntry: &github.MergeQueueEntry{ID: "MQE_1"},
				}, nil
			case 2:
				return &github.PullRequest{Number: 2, ID: "PR_2", State: "OPEN"}, nil
			case 3:
				return &github.PullRequest{Number: 3, ID: "PR_3", State: "OPEN"}, nil
			}
			return nil, nil
		},
	}

	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--short"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Out.Close()
	raw, _ := io.ReadAll(outR)
	output := string(raw)

	assert.NoError(t, err)
	assert.Contains(t, output, "b1")
	assert.Contains(t, output, "b2")
	assert.Contains(t, output, "b3")
	assert.Contains(t, output, "queued", "should show queued separator")
	assert.Contains(t, output, "◎", "should show queued icon for b1")
}

// TestViewShort_MixedQueuedAndMerged verifies that --short output shows
// both "queued" and "merged" separators in the correct order.
func TestViewShort_MixedQueuedAndMerged(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", PullRequest: &stack.PullRequestRef{Number: 2}},
			{Branch: "b3", PullRequest: &stack.PullRequestRef{Number: 3}},
		},
	}

	tmpDir := t.TempDir()
	writeStackFile(t, tmpDir, s)

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "b3", nil },
		IsAncestorFn:    func(string, string) (bool, error) { return true, nil },
		RevParseFn:      func(ref string) (string, error) { return "sha-" + ref, nil },
	})
	defer restore()

	// b1 is merged (persisted), b2 is queued (from API)
	cfg, outR, _ := config.NewTestConfig()
	cfg.GitHubClientOverride = &github.MockClient{
		FindPRByNumberFn: func(number int) (*github.PullRequest, error) {
			switch number {
			case 2:
				return &github.PullRequest{
					Number:          2,
					ID:              "PR_2",
					State:           "OPEN",
					MergeQueueEntry: &github.MergeQueueEntry{ID: "MQE_2"},
				}, nil
			case 3:
				return &github.PullRequest{Number: 3, ID: "PR_3", State: "OPEN"}, nil
			}
			return nil, nil
		},
	}

	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--short"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Out.Close()
	raw, _ := io.ReadAll(outR)
	output := string(raw)

	assert.NoError(t, err)
	assert.Contains(t, output, "queued", "should show queued separator")
	assert.Contains(t, output, "merged", "should show merged separator")

	// "merged" section (b1) should appear below "queued" section (b2) in output
	// Since we render top-to-bottom: b3 (active) -> queued separator -> b2 -> merged separator -> b1
	queuedIdx := indexOf(output, "queued")
	mergedIdx := indexOf(output, "merged")
	assert.Less(t, queuedIdx, mergedIdx, "queued separator should appear before merged separator")
}

func indexOf(s, substr string) int {
	for i := 0; i <= len(s)-len(substr); i++ {
		if s[i:i+len(substr)] == substr {
			return i
		}
	}
	return -1
}

// writeStackFileMulti writes a stack file with multiple stacks.
func writeStackFileMulti(t *testing.T, dir string, stacks ...stack.Stack) {
	t.Helper()
	sf := &stack.StackFile{
		SchemaVersion: 1,
		Stacks:        stacks,
	}
	data, err := json.MarshalIndent(sf, "", "  ")
	require.NoError(t, err)
	require.NoError(t, os.WriteFile(filepath.Join(dir, "gh-stack"), data, 0644))
}

func TestRunViewJSON_NotInStack(t *testing.T) {
	tmpDir := t.TempDir()
	writeStackFile(t, tmpDir, stack.Stack{
		Trunk:    stack.BranchRef{Branch: "main"},
		Branches: []stack.BranchRef{{Branch: "feat/01"}},
	})

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "unrelated-branch", nil },
	})
	defer restore()

	cfg, _, errR := config.NewTestConfig()
	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--json"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Err.Close()
	errOut, _ := io.ReadAll(errR)

	assert.ErrorIs(t, err, ErrNotInStack, "expected exit code 2")
	assert.Contains(t, string(errOut), "not part of a stack")
}

func TestRunViewJSON_MultipleStacks(t *testing.T) {
	tmpDir := t.TempDir()
	// "main" is the trunk of both stacks → disambiguation.
	writeStackFileMulti(t, tmpDir,
		stack.Stack{
			Trunk:    stack.BranchRef{Branch: "main"},
			Branches: []stack.BranchRef{{Branch: "feat/01"}},
		},
		stack.Stack{
			Trunk:    stack.BranchRef{Branch: "main"},
			Branches: []stack.BranchRef{{Branch: "feat/02"}},
		},
	)

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "main", nil },
	})
	defer restore()

	cfg, _, errR := config.NewTestConfig()
	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--json"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Err.Close()
	errOut, _ := io.ReadAll(errR)

	assert.ErrorIs(t, err, ErrDisambiguate, "expected exit code 6")
	assert.Contains(t, string(errOut), "belongs to multiple stacks")
}

func TestRunViewJSON_SingleStack(t *testing.T) {
	tmpDir := t.TempDir()
	writeStackFile(t, tmpDir, stack.Stack{
		Trunk: stack.BranchRef{Branch: "main", Head: "aaa"},
		Branches: []stack.BranchRef{
			{
				Branch:      "feat/01",
				Head:        "bbb",
				Base:        "aaa",
				PullRequest: &stack.PullRequestRef{Number: 10, URL: "https://github.com/o/r/pull/10"},
			},
		},
	})

	restore := git.SetOps(&git.MockOps{
		GitDirFn:        func() (string, error) { return tmpDir, nil },
		CurrentBranchFn: func() (string, error) { return "feat/01", nil },
		IsAncestorFn:    func(string, string) (bool, error) { return true, nil },
	})
	defer restore()

	cfg, outR, _ := config.NewTestConfig()
	cmd := ViewCmd(cfg)
	cmd.SetArgs([]string{"--json"})
	cmd.SetOut(io.Discard)
	cmd.SetErr(io.Discard)
	err := cmd.Execute()

	cfg.Out.Close()
	raw, _ := io.ReadAll(outR)

	require.NoError(t, err)

	var got viewJSONOutput
	require.NoError(t, json.Unmarshal(raw, &got), "output should be valid JSON: %s", string(raw))
	assert.Equal(t, "main", got.Trunk)
	assert.Len(t, got.Branches, 1)
	assert.Equal(t, "feat/01", got.Branches[0].Name)
	assert.True(t, got.Branches[0].IsCurrent)
}