//go:build !integration
package list
import (
"bufio"
"fmt"
"net/http"
"os"
"regexp"
"slices"
"strconv"
"strings"
"testing"
"time"
"github.com/MakeNowJust/heredoc/v2"
"github.com/spf13/cobra"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
gitlab "gitlab.com/gitlab-org/api/client-go/v3"
gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
"gitlab.com/gitlab-org/cli/internal/api"
"gitlab.com/gitlab-org/cli/internal/cmdutils"
"gitlab.com/gitlab-org/cli/internal/commands/issuable"
"gitlab.com/gitlab-org/cli/internal/iostreams"
"gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
)
func TestNewCmdList(t *testing.T) {
ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(true))
// No API calls are made in this test since we provide a custom runFunc
factory := cmdtest.NewTestFactory(ios)
t.Run("Issue_NewCmdList", func(t *testing.T) {
gotOpts := &ListOptions{}
err := NewCmdList(factory, func(opts *ListOptions) error {
gotOpts = opts
return nil
}, issuable.TypeIssue).Execute()
require.NoError(t, err)
assert.Equal(t, factory.IO(), gotOpts.IO)
gotBaseRepo, _ := gotOpts.BaseRepo()
expectedBaseRepo, _ := factory.BaseRepo()
assert.Equal(t, expectedBaseRepo, gotBaseRepo)
})
}
func TestNewCmdListHelpExamples(t *testing.T) {
for _, tc := range []struct {
name string
issueType issuable.IssueType
example string
}{
{name: "issue", issueType: issuable.TypeIssue, example: "glab issue list --milestone release-2.0.0"},
{name: "incident", issueType: issuable.TypeIncident, example: "glab incident list --milestone release-2.0.0"},
} {
t.Run(tc.name, func(t *testing.T) {
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
cmd := NewCmdList(f, nil, tc.issueType)
cmd.SetOut(f.IO().StdOut)
return cmd
}, false)
output, err := exec("--help")
require.NoError(t, err)
assert.Contains(t, output.String(), tc.example)
assert.NotContains(t, output.String(), "--opened")
})
}
}
func TestMilestoneFlagHelpUsesTitle(t *testing.T) {
t.Parallel()
testCases := []struct {
name string
issueType issuable.IssueType
}{
{name: "issue", issueType: issuable.TypeIssue},
{name: "incident", issueType: issuable.TypeIncident},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
ios, _, stdout, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
cmd := NewCmdList(cmdtest.NewTestFactory(ios), nil, tc.issueType)
cmd.SetOut(stdout)
cmd.SetArgs([]string{"--help"})
err := cmd.Execute()
require.NoError(t, err)
assert.Contains(t, stdout.String(), fmt.Sprintf("Filter %s by milestone
.", tc.name))
})
}
}
func TestIssueList_tty(t *testing.T) {
// NOTE: we need to force disable colors, otherwise we'd need ANSI sequences in our test output assertions.
t.Setenv("NO_COLOR", "true")
testClient := gitlabtesting.NewTestClient(t)
createdAt := time.Date(2016, 1, 4, 15, 31, 51, 0, time.UTC)
incidentType := "incident"
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return([]*gitlab.Issue{
{
ID: 76,
IID: 6,
ProjectID: 1,
State: "opened",
Title: "Issue one",
Description: "a description here",
Labels: gitlab.Labels{"foo", "bar"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/6",
CreatedAt: &createdAt,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/6",
Relative: "#6",
Short: "#6",
},
},
{
ID: 77,
IID: 7,
ProjectID: 1,
State: "opened",
Title: "Issue two",
Description: "description two here",
Labels: gitlab.Labels{"fooz", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/7",
CreatedAt: &createdAt,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/7",
Relative: "#7",
Short: "#7",
},
},
{
ID: 78,
IID: 8,
ProjectID: 1,
State: "opened",
Title: "Incident",
Description: "description incident here",
Labels: gitlab.Labels{"foo", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/8",
CreatedAt: &createdAt,
IssueType: &incidentType,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/8",
Relative: "#8",
Short: "#8",
},
},
}, nil, nil)
// Create an api.Client with the mock GitLab client
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("")
if err != nil {
t.Errorf("error running command `issue list`: %v", err)
}
out := output.String()
timeRE := regexp.MustCompile(`\d+ years`)
out = timeRE.ReplaceAllString(out, "X years")
assert.Equal(t, heredoc.Doc(`
Showing 3 open issues in OWNER/REPO that match your search. (Page 1)
ID Title Labels Created at
#6 Issue one (foo, bar) about X years ago
#7 Issue two (fooz, baz) about X years ago
#8 Incident (foo, baz) about X years ago
`), out)
assert.Empty(t, output.Stderr())
}
func TestIssueList_ids(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
createdAt := time.Date(2016, 1, 4, 15, 31, 51, 0, time.UTC)
incidentType := "incident"
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return([]*gitlab.Issue{
{
ID: 76,
IID: 6,
ProjectID: 1,
State: "opened",
Title: "Issue one",
Labels: gitlab.Labels{"foo", "bar"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/6",
CreatedAt: &createdAt,
},
{
ID: 77,
IID: 7,
ProjectID: 1,
State: "opened",
Title: "Issue two",
Labels: gitlab.Labels{"fooz", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/7",
CreatedAt: &createdAt,
},
{
ID: 78,
IID: 8,
ProjectID: 1,
State: "opened",
Title: "Incident",
Labels: gitlab.Labels{"foo", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/8",
CreatedAt: &createdAt,
IssueType: &incidentType,
},
}, nil, nil)
// Create an api.Client with the mock GitLab client
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("-F ids")
if err != nil {
t.Errorf("error running command `issue list -F ids`: %v", err)
}
assert.Equal(t, "6\n7\n8\n", output.String())
assert.Empty(t, output.Stderr())
}
func TestIssueList_urls(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
createdAt := time.Date(2016, 1, 4, 15, 31, 51, 0, time.UTC)
incidentType := "incident"
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return([]*gitlab.Issue{
{
ID: 76,
IID: 6,
ProjectID: 1,
State: "opened",
Title: "Issue one",
Labels: gitlab.Labels{"foo", "bar"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/6",
CreatedAt: &createdAt,
},
{
ID: 77,
IID: 7,
ProjectID: 1,
State: "opened",
Title: "Issue two",
Labels: gitlab.Labels{"fooz", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/7",
CreatedAt: &createdAt,
},
{
ID: 78,
IID: 8,
ProjectID: 1,
State: "opened",
Title: "Incident",
Labels: gitlab.Labels{"foo", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/8",
CreatedAt: &createdAt,
IssueType: &incidentType,
},
}, nil, nil)
// Create an api.Client with the mock GitLab client
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("-F urls")
if err != nil {
t.Errorf("error running command `issue list -F urls`: %v", err)
}
assert.Equal(t, heredoc.Doc(`
http://gitlab.com/OWNER/REPO/issues/6
http://gitlab.com/OWNER/REPO/issues/7
http://gitlab.com/OWNER/REPO/issues/8
`), output.String())
assert.Empty(t, output.Stderr())
}
func TestIssueList_tty_withFlags(t *testing.T) {
// NOTE: These subtests cannot run in parallel because they use cmdutils.GroupOverride()
// which modifies global viper state (SetEnvPrefix, BindEnv).
t.Run("project", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockUsers.EXPECT().
ListUsers(gomock.Any()).
Return([]*gitlab.User{
{ID: 100, Username: "someuser"},
}, nil, nil)
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
DoAndReturn(func(pid any, opts *gitlab.ListProjectIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
// Verify flags are passed correctly
// Note: -p is Page, -P is PerPage, so "-P1 -p100" means PerPage=1, Page=100
assert.Equal(t, "opened", *opts.State)
assert.Equal(t, int64(100), opts.Page)
assert.Equal(t, int64(1), opts.PerPage)
assert.True(t, *opts.Confidential)
assert.NotNil(t, opts.AssigneeID) // User ID 100 from someuser lookup
assert.Equal(t, gitlab.LabelOptions{"bug"}, *opts.Labels)
assert.Equal(t, "1", *opts.Milestone)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--opened -P1 -p100 --confidential -a someuser -l bug -m1")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
assert.Equal(t, `No open issues match your search in OWNER/REPO.
`, output.String())
})
t.Run("group", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListGroupIssues("GROUP", gomock.Any()).
Return([]*gitlab.Issue{}, nil, nil)
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--group GROUP")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
assert.Equal(t, `No open issues match your search in GROUP.
`, output.String())
})
}
func TestIssueList_headerTotal(t *testing.T) {
// NOTE: These subtests cannot run in parallel because the epic case uses cmdutils.GroupOverride()
// which modifies global viper state (SetEnvPrefix, BindEnv).
t.Setenv("NO_COLOR", "true")
issues := []*gitlab.Issue{
{IID: 6, State: "opened", Title: "Issue one", WebURL: "http://gitlab.com/OWNER/REPO/issues/6"},
{IID: 7, State: "opened", Title: "Issue two", WebURL: "http://gitlab.com/OWNER/REPO/issues/7"},
}
tests := []struct {
name string
issueType issuable.IssueType
cli string
setupMock func(tc *gitlabtesting.TestClient)
wantHeader string
}{
{
name: "project shows the total from the API",
issueType: issuable.TypeIssue,
cli: "",
setupMock: func(tc *gitlabtesting.TestClient) {
tc.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return(issues, &gitlab.Response{CurrentPage: 1, NextPage: 2, TotalPages: 21, TotalItems: 42}, nil)
},
wantHeader: "Showing 2 of 42 open issues in OWNER/REPO that match your search. (Page 1)\n",
},
{
name: "group shows the total from the API",
issueType: issuable.TypeIssue,
cli: "--group GROUP --per-page 2 --page 21",
setupMock: func(tc *gitlabtesting.TestClient) {
tc.MockIssues.EXPECT().
ListGroupIssues("GROUP", gomock.Any()).
Return(issues, &gitlab.Response{CurrentPage: 21, TotalPages: 21, TotalItems: 42}, nil)
},
wantHeader: "Showing 2 of 42 open issues in GROUP that match your search. (Page 21)\n",
},
{
name: "incident shows the total from the API",
issueType: issuable.TypeIncident,
cli: "",
setupMock: func(tc *gitlabtesting.TestClient) {
tc.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return(issues, &gitlab.Response{CurrentPage: 1, NextPage: 2, TotalPages: 3, TotalItems: 5}, nil)
},
wantHeader: "Showing 2 of 5 open incidents in OWNER/REPO that match your search. (Page 1)\n",
},
{
name: "project without a total from the API",
issueType: issuable.TypeIssue,
cli: "",
setupMock: func(tc *gitlabtesting.TestClient) {
tc.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return(issues, &gitlab.Response{CurrentPage: 1, NextPage: 2}, nil)
},
wantHeader: "Showing 2 open issues in OWNER/REPO that match your search. (Page 1)\n",
},
{
name: "epic ignores the total from the API",
issueType: issuable.TypeIssue,
cli: "--group GROUP --epic 42",
setupMock: func(tc *gitlabtesting.TestClient) {
tc.MockEpicIssues.EXPECT().
ListEpicIssues("GROUP", int64(42), gomock.Any()).
Return(issues, &gitlab.Response{CurrentPage: 1, TotalPages: 1, TotalItems: 42}, nil)
},
wantHeader: "Showing 2 open issues in GROUP&42 that match your search. (Page 1)\n",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
tt.setupMock(testClient)
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, tt.issueType)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec(tt.cli)
require.NoError(t, err)
assert.True(t, strings.HasPrefix(output.String(), tt.wantHeader), "got %q", output.String())
assert.Empty(t, output.Stderr())
})
}
}
func TestIssueList_groupPassesConfidentialAndIteration(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListGroupIssues("GROUP", gomock.Any()).
DoAndReturn(func(gid any, opts *gitlab.ListGroupIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
require.NotNil(t, opts.Confidential, "confidential filter dropped for group listing")
assert.True(t, *opts.Confidential)
require.NotNil(t, opts.IterationID, "iteration filter dropped for group listing")
assert.Equal(t, int64(9), *opts.IterationID)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--group GROUP --confidential --iteration 9")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
}
func TestIssueList_filterByIteration(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
DoAndReturn(func(pid any, opts *gitlab.ListProjectIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
// Verify iteration_id is passed
assert.Equal(t, int64(9), *opts.IterationID)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--iteration 9")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
assert.Equal(t, `No open issues match your search in OWNER/REPO.
`, output.String())
}
func TestIssueList_filterByDates(t *testing.T) {
// NOTE: These subtests cannot run in parallel because they use cmdutils.GroupOverride()
// which modifies global viper state (SetEnvPrefix, BindEnv).
t.Run("project", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
DoAndReturn(func(pid any, opts *gitlab.ListProjectIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
require.NotNil(t, opts.CreatedAfter)
require.NotNil(t, opts.CreatedBefore)
require.NotNil(t, opts.UpdatedAfter)
require.NotNil(t, opts.UpdatedBefore)
assert.Equal(t, time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC), *opts.CreatedAfter)
assert.Equal(t, time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC), *opts.CreatedBefore)
assert.Equal(t, time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC), *opts.UpdatedAfter)
assert.Equal(t, time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC), *opts.UpdatedBefore)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--created-after 2026-01-01T00:00:00Z --created-before 2026-02-01T00:00:00Z --updated-after 2026-03-01T00:00:00Z --updated-before 2026-04-01T00:00:00Z")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
assert.Equal(t, `No open issues match your search in OWNER/REPO.
`, output.String())
})
t.Run("no date flags", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
DoAndReturn(func(pid any, opts *gitlab.ListProjectIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
assert.Nil(t, opts.CreatedAfter)
assert.Nil(t, opts.CreatedBefore)
assert.Nil(t, opts.UpdatedAfter)
assert.Nil(t, opts.UpdatedBefore)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
_, err = exec("")
require.NoError(t, err)
})
t.Run("group", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListGroupIssues("GROUP", gomock.Any()).
DoAndReturn(func(gid any, opts *gitlab.ListGroupIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
require.NotNil(t, opts.UpdatedAfter)
assert.Equal(t, time.Date(2026, 10, 1, 0, 0, 0, 0, time.UTC), *opts.UpdatedAfter)
assert.Nil(t, opts.CreatedAfter)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--group GROUP --updated-after 2026-10-01T00:00:00Z")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
assert.Equal(t, `No open issues match your search in GROUP.
`, output.String())
})
t.Run("invalid format", func(t *testing.T) {
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
_, err := exec("--created-after 2026-10-01")
require.ErrorContains(t, err, "invalid time format")
})
}
func TestIssueList_tty_withIssueType(t *testing.T) {
// NOTE: we need to force disable colors, otherwise we'd need ANSI sequences in our test output assertions.
t.Setenv("NO_COLOR", "true")
testClient := gitlabtesting.NewTestClient(t)
createdAt := time.Date(2016, 1, 4, 15, 31, 51, 0, time.UTC)
incidentType := "incident"
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
DoAndReturn(func(pid any, opts *gitlab.ListProjectIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
// Verify issue_type filter is passed
assert.Equal(t, new("incident"), opts.IssueType)
return []*gitlab.Issue{
{
ID: 78,
IID: 8,
ProjectID: 1,
State: "opened",
Title: "Incident",
Description: "description incident here",
Labels: gitlab.Labels{"foo", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/8",
CreatedAt: &createdAt,
IssueType: &incidentType,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/8",
Relative: "#8",
Short: "#8",
},
},
}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--issue-type=incident")
require.NoError(t, err)
out := output.String()
timeRE := regexp.MustCompile(`\d+ years`)
out = timeRE.ReplaceAllString(out, "X years")
assert.Contains(t, out, "Showing 1 open incident in OWNER/REPO that match your search. (Page 1)")
assert.Contains(t, out, "#8\tIncident\t(foo, baz)\tabout X years ago")
assert.Empty(t, output.Stderr())
}
func TestIncidentList_tty_withIssueType(t *testing.T) {
// This test doesn't need API mocking - it just tests that --issue-type flag
// is not allowed for incident command
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIncident)
}, true,
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--issue-type=incident")
if err == nil {
t.Error("expected an `unknown flag: --issue-type` error, but got nothing")
}
assert.Empty(t, output.String())
assert.Empty(t, output.Stderr())
}
func TestIssueList_tty_mine(t *testing.T) {
t.Run("mine with all flag and user exists", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockUsers.EXPECT().
CurrentUser(gomock.Any()).
Return(&gitlab.User{Username: "john_smith"}, nil, nil)
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
DoAndReturn(func(pid any, opts *gitlab.ListProjectIssuesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
// Verify assignee ID is set from current user lookup
assert.NotNil(t, opts.AssigneeID)
return []*gitlab.Issue{}, nil, nil
})
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--mine -A")
require.NoError(t, err)
assert.Empty(t, output.Stderr())
assert.Equal(t, `No issues match your search in OWNER/REPO.
`, output.String())
})
t.Run("user does not exists", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
notFoundResp := &gitlab.Response{
Response: &http.Response{StatusCode: http.StatusNotFound},
}
testClient.MockUsers.EXPECT().
CurrentUser(gomock.Any()).
Return(nil, notFoundResp, gitlab.ErrNotFound)
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--mine -A")
require.Error(t, err)
assert.Empty(t, output.Stderr())
assert.Empty(t, output.String())
})
}
func makeHyperlink(linkText, targetURL string) string {
return fmt.Sprintf("\x1b]8;;%s\x1b\\%s\x1b]8;;\x1b\\", targetURL, linkText)
}
func TestIssueList_hyperlinks(t *testing.T) {
// NOTE: we need to force disable colors, otherwise we'd need ANSI sequences in our test output assertions.
t.Setenv("NO_COLOR", "true")
noHyperlinkCells := [][]string{
{"#6", "Issue one", "(foo, bar)", "about X years ago"},
{"#7", "Issue two", "(fooz, baz)", "about X years ago"},
{"#8", "Incident", "(foo, baz)", "about X years ago"},
}
hyperlinkCells := [][]string{
{makeHyperlink("#6", "http://gitlab.com/OWNER/REPO/issues/6"), "Issue one", "(foo, bar)", "about X years ago"},
{makeHyperlink("#7", "http://gitlab.com/OWNER/REPO/issues/7"), "Issue two", "(fooz, baz)", "about X years ago"},
{makeHyperlink("#8", "http://gitlab.com/OWNER/REPO/issues/8"), "Incident", "(foo, baz)", "about X years ago"},
}
type hyperlinkTest struct {
forceHyperlinksEnv string
displayHyperlinksConfig string
isTTY bool
expectedCells [][]string
}
tests := []hyperlinkTest{
// FORCE_HYPERLINKS causes hyperlinks to be output, whether or not we're talking to a TTY
{forceHyperlinksEnv: "1", isTTY: true, expectedCells: hyperlinkCells},
{forceHyperlinksEnv: "1", isTTY: false, expectedCells: hyperlinkCells},
// empty/missing display_hyperlinks in config defaults to *not* outputting hyperlinks
{displayHyperlinksConfig: "", isTTY: true, expectedCells: noHyperlinkCells},
{displayHyperlinksConfig: "", isTTY: false, expectedCells: noHyperlinkCells},
// display_hyperlinks: false in config prevents outputting hyperlinks
{displayHyperlinksConfig: "false", isTTY: true, expectedCells: noHyperlinkCells},
{displayHyperlinksConfig: "false", isTTY: false, expectedCells: noHyperlinkCells},
// display_hyperlinks: true in config only outputs hyperlinks if we're talking to a TTY
{displayHyperlinksConfig: "true", isTTY: true, expectedCells: hyperlinkCells},
{displayHyperlinksConfig: "true", isTTY: false, expectedCells: noHyperlinkCells},
}
createdAt1 := time.Date(2016, 1, 4, 15, 31, 51, 0, time.UTC)
createdAt2 := time.Date(2016, 1, 4, 16, 31, 51, 0, time.UTC)
incidentType := "incident"
testIssues := []*gitlab.Issue{
{
ID: 76,
IID: 6,
ProjectID: 1,
State: "opened",
Title: "Issue one",
Description: "a description here",
Labels: gitlab.Labels{"foo", "bar"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/6",
CreatedAt: &createdAt1,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/6",
Relative: "#6",
Short: "#6",
},
},
{
ID: 77,
IID: 7,
ProjectID: 1,
State: "opened",
Title: "Issue two",
Description: "description two here",
Labels: gitlab.Labels{"fooz", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/7",
CreatedAt: &createdAt1,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/7",
Relative: "#7",
Short: "#7",
},
},
{
ID: 78,
IID: 8,
ProjectID: 1,
State: "opened",
Title: "Incident",
Description: "description incident here",
Labels: gitlab.Labels{"foo", "baz"},
WebURL: "http://gitlab.com/OWNER/REPO/issues/8",
CreatedAt: &createdAt2,
IssueType: &incidentType,
References: &gitlab.IssueReferences{
Full: "OWNER/REPO/issues/8",
Relative: "#8",
Short: "#8",
},
},
}
for _, tc := range tests {
t.Run("", func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return(testIssues, nil, nil)
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
doHyperlinks := "never"
if tc.forceHyperlinksEnv == "1" {
doHyperlinks = "always"
} else if tc.displayHyperlinksConfig == "true" {
doHyperlinks = "auto"
}
ios, _, _, _ := cmdtest.TestIOStreams(
cmdtest.WithTestIOStreamsAsTTY(tc.isTTY),
iostreams.WithDisplayHyperLinks(doHyperlinks),
)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, tc.isTTY,
cmdtest.WithIOStreamsOverride(ios),
cmdtest.WithApiClient(apiClient),
cmdtest.WithGitLabClient(testClient.Client),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("")
require.NoError(t, err)
out := output.String()
timeRE := regexp.MustCompile(`\d+ years`)
out = timeRE.ReplaceAllString(out, "X years")
lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
// first two lines have the header and some separating whitespace, so skip those
for lineNum, line := range lines[3:] {
gotCells := strings.Split(line, "\t")
expectedCells := tc.expectedCells[lineNum]
assert.Len(t, gotCells, len(expectedCells))
for cellNum, gotCell := range gotCells {
expectedCell := expectedCells[cellNum]
assert.Equal(t, expectedCell, strings.Trim(gotCell, " "))
}
}
})
}
}
func TestIssueListJSON(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
createdAt, _ := time.Parse(time.RFC3339, "2024-01-31T05:37:57.883Z")
updatedAt, _ := time.Parse(time.RFC3339, "2024-02-02T00:54:02.842Z")
issueType := "issue"
testIssue := &gitlab.Issue{
ID: 141525495,
IID: 15,
ProjectID: 37777023,
Title: "tem",
Description: "",
State: "opened",
CreatedAt: &createdAt,
UpdatedAt: &updatedAt,
Labels: gitlab.Labels{},
Assignees: []*gitlab.IssueAssignee{},
Author: &gitlab.IssueAuthor{ID: 11809982, Username: "jay_mccure", Name: "Jay McCure", State: "active", AvatarURL: "https://gitlab.com/uploads/-/system/user/avatar/11809982/avatar.png", WebURL: "https://gitlab.com/jay_mccure"},
Confidential: false,
IssueType: &issueType,
WebURL: "https://gitlab.com/jay_mccure/test2target/-/issues/15",
TimeStats: &gitlab.TimeStats{},
TaskCompletionStatus: &gitlab.TasksCompletionStatus{Count: 0, CompletedCount: 0},
Links: &gitlab.IssueLinks{Self: "https://gitlab.com/api/v4/projects/37777023/issues/15", Notes: "https://gitlab.com/api/v4/projects/37777023/issues/15/notes", AwardEmoji: "https://gitlab.com/api/v4/projects/37777023/issues/15/award_emoji", Project: "https://gitlab.com/api/v4/projects/37777023"},
References: &gitlab.IssueReferences{Short: "#15", Relative: "#15", Full: "jay_mccure/test2target#15"},
}
testClient.MockIssues.EXPECT().
ListProjectIssues("OWNER/REPO", gomock.Any()).
Return([]*gitlab.Issue{testIssue}, nil, nil)
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec("--output json")
require.NoError(t, err)
b, err := os.ReadFile("./testdata/issueListFull.json")
require.NoError(t, err)
expectedOut := string(b)
assert.JSONEq(t, expectedOut, output.String())
assert.Empty(t, output.Stderr())
}
func TestIssueListMutualOutputFlags(t *testing.T) {
// This test doesn't need API mocking - it just tests flag validation
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
_, err := exec("--output json --output-format ids")
require.Error(t, err)
assert.EqualError(t, err, "if any flags in the group [output output-format] are set none of the others can be; [output output-format] were all set")
}
func TestIssueAndIncidentListRejectInvalidOutputFlags(t *testing.T) {
for _, issueType := range []issuable.IssueType{issuable.TypeIssue, issuable.TypeIncident} {
t.Run(string(issueType), func(t *testing.T) {
for _, flag := range []string{"--output invalid", "--output \"\"", "--output-format invalid", "--output-format \"\""} {
t.Run(flag, func(t *testing.T) {
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issueType)
}, true)
_, err := exec(flag)
require.ErrorContains(t, err, "must be one of")
})
}
})
}
}
func TestIssueList_epicIssues(t *testing.T) {
// NOTE: This test cannot run in parallel because it uses cmdutils.GroupOverride()
// which modifies global viper state (SetEnvPrefix, BindEnv).
testdata := []*gitlab.Issue{
{
IID: 1,
State: "opened",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::one"},
Milestone: &gitlab.Milestone{
Title: "Milestone one",
},
Title: "This is issue one",
Iteration: &gitlab.GroupIteration{
ID: 103,
},
Confidential: false,
CreatedAt: new(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)),
UpdatedAt: new(time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)),
},
{
IID: 2,
State: "closed",
Assignees: []*gitlab.IssueAssignee{
{ID: 102},
},
Author: &gitlab.IssueAuthor{ID: 202},
Labels: gitlab.Labels{"label::two"},
Milestone: &gitlab.Milestone{
Title: "Milestone two",
},
Title: "That is issue two",
Iteration: &gitlab.GroupIteration{
ID: 203,
},
Confidential: true,
CreatedAt: new(time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC)),
UpdatedAt: new(time.Date(2026, 4, 1, 0, 0, 0, 0, time.UTC)),
},
}
tests := []struct {
name string
commandLine string
user *gitlab.User
wantIDs []int
wantErr string
perPage int
}{
{
name: "group flag",
commandLine: `--group testGroupID --epic 42`,
wantIDs: []int{1},
},
{
name: "repo flag",
commandLine: `--repo testGroupID/repo --epic 42`,
wantIDs: []int{1},
},
{
name: "all flag",
commandLine: `--group testGroupID --epic 42 --all`,
wantIDs: []int{1, 2},
},
{
name: "closed flag",
commandLine: `--group testGroupID --epic 42 --closed`,
wantIDs: []int{2},
},
{
name: "assignee flag",
user: &gitlab.User{
ID: 101,
Username: "one-oh-one",
},
commandLine: `--group testGroupID --epic 42 --all --assignee one-oh-one`,
wantIDs: []int{1},
},
{
name: "not-assignee flag",
user: &gitlab.User{
ID: 101,
Username: "one-oh-one",
},
commandLine: `--group testGroupID --epic 42 --all --not-assignee one-oh-one`,
wantIDs: []int{2},
},
{
name: "author flag",
user: &gitlab.User{
ID: 102,
Username: "one-oh-two",
},
commandLine: `--group testGroupID --epic 42 --all --author one-oh-two`,
wantIDs: []int{1},
},
{
name: "not-author flag",
user: &gitlab.User{
ID: 102,
Username: "one-oh-two",
},
commandLine: `--group testGroupID --epic 42 --all --not-author one-oh-two`,
wantIDs: []int{2},
},
{
name: "milestone flag",
commandLine: `--group testGroupID --epic 42 --all --milestone 'milestone one'`,
wantIDs: []int{1},
},
{
name: "search flag",
commandLine: `--group testGroupID --epic 42 --all --search 'iSsUe OnE'`,
wantIDs: []int{1},
},
{
name: "iteration flag",
commandLine: `--group testGroupID --epic 42 --all --iteration 103`,
wantIDs: []int{1},
},
{
name: "confidential flag",
commandLine: `--group testGroupID --epic 42 --all --confidential`,
wantIDs: []int{2},
},
{
name: "created-after flag",
commandLine: `--group testGroupID --epic 42 --all --created-after 2026-01-15T00:00:00Z`,
wantIDs: []int{2},
},
{
name: "created-before flag",
commandLine: `--group testGroupID --epic 42 --all --created-before 2026-01-15T00:00:00Z`,
wantIDs: []int{1},
},
{
name: "updated-after flag",
commandLine: `--group testGroupID --epic 42 --all --updated-after 2026-03-15T00:00:00Z`,
wantIDs: []int{2},
},
{
name: "updated-before flag",
commandLine: `--group testGroupID --epic 42 --all --updated-before 2026-03-15T00:00:00Z`,
wantIDs: []int{1},
},
{
name: "date flags include the boundary",
commandLine: `--group testGroupID --epic 42 --all --created-after 2026-02-01T00:00:00Z --created-before 2026-02-01T00:00:00Z`,
wantIDs: []int{2},
},
{
name: "page flag",
commandLine: `--group testGroupID --epic 42 --all --page=2`,
wantErr: "the --page flag",
},
{
name: "per-page flag",
commandLine: `--group testGroupID --epic 42 --all --per-page=9999`,
// per-page is clamped to the max supported per_page value
perPage: api.MaxPerPage,
wantIDs: []int{1, 2},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
if tt.user != nil {
testClient.MockUsers.EXPECT().
ListUsers(gomock.Any()).
Return([]*gitlab.User{tt.user}, nil, nil)
}
if tt.wantErr == "" {
testClient.MockEpicIssues.EXPECT().
ListEpicIssues("testGroupID", int64(42), gomock.Any()).
DoAndReturn(func(gid any, epic int64, opts *gitlab.ListOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Issue, *gitlab.Response, error) {
if tt.perPage != 0 {
assert.Equal(t, int64(tt.perPage), opts.PerPage)
}
return testdata, &gitlab.Response{NextPage: 0}, nil
})
}
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
output, err := exec(tt.commandLine + ` --output-format ids`)
if tt.wantErr != "" {
require.ErrorContains(t, err, tt.wantErr)
}
if err != nil {
return
}
assert.Empty(t, output.Stderr())
gotIDs, err := strToIntSlice(output.String())
if err != nil {
t.Fatalf("command %q: unexpected output:\n%s", tt.commandLine, output.String())
}
assert.Equal(t, tt.wantIDs, gotIDs)
})
}
}
func TestIssueList_filterByLabel(t *testing.T) {
// NOTE: This test cannot run in parallel because it uses cmdutils.GroupOverride()
// which modifies global viper state (SetEnvPrefix, BindEnv).
tests := map[string]struct {
respBody []*gitlab.Issue
args string
expect []int
}{
"with --label": {
respBody: []*gitlab.Issue{
{
IID: 1,
State: "opened",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::one"},
Milestone: &gitlab.Milestone{
Title: "Milestone one",
},
Title: "This is issue one",
Iteration: &gitlab.GroupIteration{
ID: 103,
},
Confidential: false,
},
{
IID: 2,
State: "open",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::one"},
Milestone: &gitlab.Milestone{
Title: "Milestone two",
},
Title: "That is issue two",
Iteration: &gitlab.GroupIteration{
ID: 203,
},
Confidential: false,
},
},
args: "--group testGroupID --epic 42 --all --label label::one",
expect: []int{1, 2},
},
"with --not-label": {
respBody: []*gitlab.Issue{
{
IID: 3,
State: "open",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::two"},
Milestone: &gitlab.Milestone{
Title: "Milestone two",
},
Title: "That is issue three",
Iteration: &gitlab.GroupIteration{
ID: 303,
},
Confidential: false,
},
},
args: "--group testGroupID --epic 42 --all --not-label label::one",
expect: []int{3},
},
"with --label and --not-label": {
respBody: []*gitlab.Issue{
{
IID: 1,
State: "opened",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::one"},
Milestone: &gitlab.Milestone{
Title: "Milestone one",
},
Title: "This is issue one",
Iteration: &gitlab.GroupIteration{
ID: 103,
},
Confidential: false,
},
{
IID: 2,
State: "open",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::one"},
Milestone: &gitlab.Milestone{
Title: "Milestone two",
},
Title: "That is issue two",
Iteration: &gitlab.GroupIteration{
ID: 203,
},
Confidential: false,
},
{
IID: 3,
State: "open",
Assignees: []*gitlab.IssueAssignee{
{ID: 101},
},
Author: &gitlab.IssueAuthor{ID: 102},
Labels: gitlab.Labels{"label::two"},
Milestone: &gitlab.Milestone{
Title: "Milestone two",
},
Title: "That is issue three",
Iteration: &gitlab.GroupIteration{
ID: 303,
},
Confidential: false,
},
},
args: "--group testGroupID --epic 42 --all --label label::one --not-label label::three",
expect: []int{1, 2, 3},
},
}
for name, tt := range tests {
t.Run(name, func(t *testing.T) {
testClient := gitlabtesting.NewTestClient(t)
testClient.MockEpicIssues.EXPECT().
ListEpicIssues("testGroupID", int64(42), gomock.Any()).
Return(tt.respBody, &gitlab.Response{NextPage: 0}, nil)
apiClient, err := api.NewClient(
func(*http.Client) (gitlab.AuthSource, error) {
return gitlab.AccessTokenAuthSource{Token: "test-token"}, nil
},
api.WithGitLabClient(testClient.Client),
)
require.NoError(t, err)
exec := cmdtest.SetupCmdForTest(t, func(f cmdutils.Factory) *cobra.Command {
return NewCmdList(f, nil, issuable.TypeIssue)
}, true,
cmdtest.WithApiClient(apiClient),
cmdtest.WithBaseRepo("OWNER", "REPO", ""),
)
out, err := exec(tt.args + " --output-format ids")
require.NoError(t, err, "command: %s err: %v", tt.args, err)
require.Emptyf(t, out.Stderr(), "command: %s stderr: %s", tt.args, out.Stderr())
got, err := strToIntSlice(out.String())
require.NoErrorf(t, err, "command: %s output:\n%s", tt.args, out)
assert.Equal(t, tt.expect, got)
})
}
}
func strToIntSlice(s string) ([]int, error) {
var ret []int
scanner := bufio.NewScanner(strings.NewReader(s))
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
if line == "" {
continue
}
i, err := strconv.Atoi(line)
if err != nil {
return nil, err
}
ret = append(ret, i)
}
slices.Sort(ret)
return ret, nil
}