Add label list and label create commands (#5316)

pkg/cmd/label/create/create.go

@@ -0,0 +1,134 @@
+package create
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/MakeNowJust/heredoc"
+	"github.com/cli/cli/v2/api"
+	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/pkg/cmd/label/shared"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/spf13/cobra"
+)
+
+var randomColors = []string{
+	"B60205",
+	"D93F0B",
+	"FBCA04",
+	"0E8A16",
+	"006B75",
+	"1D76DB",
+	"0052CC",
+	"5319E7",
+	"E99695",
+	"F9D0C4",
+	"FEF2C0",
+	"C2E0C6",
+	"BFDADC",
+	"C5DEF5",
+	"BFD4F2",
+	"D4C5F9",
+}
+
+type CreateOptions struct {
+	BaseRepo   func() (ghrepo.Interface, error)
+	HttpClient func() (*http.Client, error)
+	IO         *iostreams.IOStreams
+
+	Color       string
+	Description string
+	Name        string
+}
+
+func NewCmdCreate(f *cmdutil.Factory, runF func(*CreateOptions) error) *cobra.Command {
+	opts := CreateOptions{
+		HttpClient: f.HttpClient,
+		IO:         f.IOStreams,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "create <name>",
+		Short: "Create a new label",
+		Long: heredoc.Docf(`
+			Create a new label on GitHub.
+
+			Must specify name for the label, the description and color are optional.
+			If a color isn't provided, a random one will be chosen.
+
+			Color needs to be 6 character hex value.
+		`),
+		Example: heredoc.Doc(`
+			$ gh label create bug --description "Something isn't working" --color E99695
+	  `),
+		Args: cmdutil.ExactArgs(1, "cannot create label: name argument required"),
+		RunE: func(c *cobra.Command, args []string) error {
+			opts.BaseRepo = f.BaseRepo
+			opts.Name = args[0]
+			opts.Color = strings.TrimPrefix(opts.Color, "#")
+			if runF != nil {
+				return runF(&opts)
+			}
+			return createRun(&opts)
+		},
+	}
+
+	cmd.Flags().StringVarP(&opts.Description, "description", "d", "", "Description of the label")
+	cmd.Flags().StringVarP(&opts.Color, "color", "c", "", "Color of the label, if not specified one will be selected at random")
+
+	return cmd
+}
+
+func createRun(opts *CreateOptions) error {
+	httpClient, err := opts.HttpClient()
+	if err != nil {
+		return err
+	}
+
+	baseRepo, err := opts.BaseRepo()
+	if err != nil {
+		return err
+	}
+
+	if opts.Color == "" {
+		rand.Seed(time.Now().UnixNano())
+		opts.Color = randomColors[rand.Intn(len(randomColors)-1)]
+	}
+
+	opts.IO.StartProgressIndicator()
+	err = createLabel(httpClient, baseRepo, opts)
+	opts.IO.StopProgressIndicator()
+	if err != nil {
+		return err
+	}
+
+	if opts.IO.IsStdoutTTY() {
+		cs := opts.IO.ColorScheme()
+		successMsg := fmt.Sprintf("\n%s Label %q created in %s\n", cs.SuccessIcon(), opts.Name, ghrepo.FullName(baseRepo))
+		fmt.Fprint(opts.IO.Out, successMsg)
+	}
+
+	return nil
+}
+
+func createLabel(client *http.Client, repo ghrepo.Interface, opts *CreateOptions) error {
+	apiClient := api.NewClientFromHTTP(client)
+	path := fmt.Sprintf("repos/%s/%s/labels", repo.RepoOwner(), repo.RepoName())
+	requestByte, err := json.Marshal(map[string]string{
+		"name":        opts.Name,
+		"description": opts.Description,
+		"color":       opts.Color,
+	})
+	if err != nil {
+		return err
+	}
+	requestBody := bytes.NewReader(requestByte)
+	result := shared.Label{}
+	return apiClient.REST(repo.RepoHost(), "POST", path, requestBody, &result)
+}

pkg/cmd/label/create/create_test.go

@@ -0,0 +1,151 @@
+package create
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/httpmock"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewCmdCreate(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		output  CreateOptions
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name:    "no argument",
+			input:   "",
+			wantErr: true,
+			errMsg:  "cannot create label: name argument required",
+		},
+		{
+			name:   "name argument",
+			input:  "test",
+			output: CreateOptions{Name: "test"},
+		},
+		{
+			name:   "description flag",
+			input:  "test --description 'some description'",
+			output: CreateOptions{Name: "test", Description: "some description"},
+		},
+		{
+			name:   "color flag",
+			input:  "test --color FFFFFF",
+			output: CreateOptions{Name: "test", Color: "FFFFFF"},
+		},
+		{
+			name:   "color flag with pound sign",
+			input:  "test --color '#AAAAAA'",
+			output: CreateOptions{Name: "test", Color: "AAAAAA"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			io, _, _, _ := iostreams.Test()
+			f := &cmdutil.Factory{
+				IOStreams: io,
+			}
+			argv, err := shlex.Split(tt.input)
+			assert.NoError(t, err)
+			var gotOpts *CreateOptions
+			cmd := NewCmdCreate(f, func(opts *CreateOptions) error {
+				gotOpts = opts
+				return nil
+			})
+			cmd.SetArgs(argv)
+			cmd.SetIn(&bytes.Buffer{})
+			cmd.SetOut(&bytes.Buffer{})
+			cmd.SetErr(&bytes.Buffer{})
+
+			_, err = cmd.ExecuteC()
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.errMsg)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.output.Color, gotOpts.Color)
+			assert.Equal(t, tt.output.Description, gotOpts.Description)
+			assert.Equal(t, tt.output.Name, gotOpts.Name)
+		})
+	}
+}
+
+func TestCreateRun(t *testing.T) {
+	tests := []struct {
+		name       string
+		tty        bool
+		opts       *CreateOptions
+		httpStubs  func(*httpmock.Registry)
+		wantStdout string
+	}{
+		{
+			name: "creates label",
+			tty:  true,
+			opts: &CreateOptions{Name: "test", Description: "some description"},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.REST("POST", "repos/OWNER/REPO/labels"),
+					httpmock.StatusStringResponse(201, "{}"),
+				)
+			},
+			wantStdout: "\n✓ Label \"test\" created in OWNER/REPO\n",
+		},
+		{
+			name: "creates label notty",
+			tty:  false,
+			opts: &CreateOptions{Name: "test", Description: "some description"},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.REST("POST", "repos/OWNER/REPO/labels"),
+					httpmock.StatusStringResponse(201, "{}"),
+				)
+			},
+			wantStdout: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reg := &httpmock.Registry{}
+			if tt.httpStubs != nil {
+				tt.httpStubs(reg)
+			}
+			tt.opts.HttpClient = func() (*http.Client, error) {
+				return &http.Client{Transport: reg}, nil
+			}
+			io, _, stdout, _ := iostreams.Test()
+			io.SetStdoutTTY(tt.tty)
+			io.SetStdinTTY(tt.tty)
+			io.SetStderrTTY(tt.tty)
+			tt.opts.IO = io
+			tt.opts.BaseRepo = func() (ghrepo.Interface, error) {
+				return ghrepo.New("OWNER", "REPO"), nil
+			}
+			defer reg.Verify(t)
+			err := createRun(tt.opts)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.wantStdout, stdout.String())
+
+			bodyBytes, _ := ioutil.ReadAll(reg.Requests[0].Body)
+			reqBody := map[string]string{}
+			err = json.Unmarshal(bodyBytes, &reqBody)
+			assert.NoError(t, err)
+			assert.NotEqual(t, "", reqBody["color"])
+			assert.Equal(t, "some description", reqBody["description"])
+			assert.Equal(t, "test", reqBody["name"])
+		})
+	}
+}

pkg/cmd/label/label.go

@@ -0,0 +1,22 @@
+package label
+
+import (
+	labelCreateCmd "github.com/cli/cli/v2/pkg/cmd/label/create"
+	labelListCmd "github.com/cli/cli/v2/pkg/cmd/label/list"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/spf13/cobra"
+)
+
+func NewCmdLabel(f *cmdutil.Factory) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "label <command>",
+		Short: "Manage labels",
+		Long:  `Work with GitHub labels.`,
+	}
+	cmdutil.EnableRepoOverride(cmd, f)
+
+	cmd.AddCommand(labelListCmd.NewCmdList(f, nil))
+	cmd.AddCommand(labelCreateCmd.NewCmdCreate(f, nil))
+
+	return cmd
+}

pkg/cmd/label/list/http.go

@@ -0,0 +1,88 @@
+package list
+
+import (
+	"net/http"
+
+	"github.com/cli/cli/v2/api"
+	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/pkg/cmd/label/shared"
+)
+
+func listLabels(client *http.Client, repo ghrepo.Interface, limit int) ([]shared.Label, int, error) {
+	apiClient := api.NewClientFromHTTP(client)
+	query := `
+	query LabelList($owner: String!,$repo: String!, $limit: Int!, $endCursor: String) {
+		repository(owner: $owner, name: $repo) {
+			labels(first: $limit, after: $endCursor) {
+				totalCount,
+				nodes {
+					name,
+					description,
+					color
+				}
+				pageInfo {
+					hasNextPage
+					endCursor
+				}
+			}
+		}
+	}`
+
+	variables := map[string]interface{}{
+		"owner": repo.RepoOwner(),
+		"repo":  repo.RepoName(),
+	}
+
+	type responseData struct {
+		Repository struct {
+			Labels struct {
+				TotalCount int
+				Nodes      []shared.Label
+				PageInfo   struct {
+					HasNextPage bool
+					EndCursor   string
+				}
+			}
+			HasIssuesEnabled bool
+		}
+	}
+
+	var labels []shared.Label
+	var totalCount int
+	pageLimit := min(limit, 100)
+
+loop:
+	for {
+		var response responseData
+		variables["limit"] = pageLimit
+		err := apiClient.GraphQL(repo.RepoHost(), query, variables, &response)
+		if err != nil {
+			return nil, 0, err
+		}
+
+		totalCount = response.Repository.Labels.TotalCount
+
+		for _, label := range response.Repository.Labels.Nodes {
+			labels = append(labels, label)
+			if len(labels) == limit {
+				break loop
+			}
+		}
+
+		if response.Repository.Labels.PageInfo.HasNextPage {
+			variables["endCursor"] = response.Repository.Labels.PageInfo.EndCursor
+			pageLimit = min(pageLimit, limit-len(labels))
+		} else {
+			break
+		}
+	}
+
+	return labels, totalCount, nil
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

pkg/cmd/label/list/http_test.go

@@ -0,0 +1,80 @@
+package list
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/pkg/httpmock"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLabelList_pagination(t *testing.T) {
+	reg := &httpmock.Registry{}
+	client := &http.Client{Transport: reg}
+
+	reg.Register(
+		httpmock.GraphQL(`query LabelList\b`),
+		httpmock.StringResponse(`
+		{
+			"data": {
+				"repository": {
+					"labels": {
+						"totalCount": 2,
+						"nodes": [
+							{
+								"name": "bug",
+								"color": "d73a4a",
+								"description": "This is a bug label"
+							}
+						],
+						"pageInfo": {
+							"hasNextPage": true,
+							"endCursor": "Y3Vyc29yOnYyOpK5MjAxOS0xMC0xMVQwMTozODowMyswODowMM5f3HZq"
+						}
+					}
+				}
+			}
+		}`),
+	)
+
+	reg.Register(
+		httpmock.GraphQL(`query LabelList\b`),
+		httpmock.StringResponse(`
+		{
+			"data": {
+				"repository": {
+					"labels": {
+						"totalCount": 2,
+						"nodes": [
+							{
+								"name": "docs",
+								"color": "ffa8da",
+								"description": "This is a docs label"
+							}
+						],
+						"pageInfo": {
+							"hasNextPage": false,
+							"endCursor": "Y3Vyc29yOnYyOpK5MjAyMi0wMS0zMVQxODo1NTo1MiswODowMM7hiAL3"
+						}
+					}
+				}
+			}
+		}`),
+	)
+
+	repo := ghrepo.New("OWNER", "REPO")
+	labels, totalCount, err := listLabels(client, repo, 10)
+	assert.NoError(t, err)
+
+	assert.Equal(t, 2, totalCount)
+	assert.Equal(t, 2, len(labels))
+
+	assert.Equal(t, "bug", labels[0].Name)
+	assert.Equal(t, "d73a4a", labels[0].Color)
+	assert.Equal(t, "This is a bug label", labels[0].Description)
+
+	assert.Equal(t, "docs", labels[1].Name)
+	assert.Equal(t, "ffa8da", labels[1].Color)
+	assert.Equal(t, "This is a docs label", labels[1].Description)
+}

pkg/cmd/label/list/list.go

@@ -0,0 +1,126 @@
+package list
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/pkg/cmd/label/shared"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/cli/cli/v2/utils"
+	"github.com/spf13/cobra"
+)
+
+type browser interface {
+	Browse(string) error
+}
+
+type ListOptions struct {
+	BaseRepo   func() (ghrepo.Interface, error)
+	Browser    browser
+	HttpClient func() (*http.Client, error)
+	IO         *iostreams.IOStreams
+
+	Limit   int
+	WebMode bool
+}
+
+func NewCmdList(f *cmdutil.Factory, runF func(*ListOptions) error) *cobra.Command {
+	opts := ListOptions{
+		Browser:    f.Browser,
+		HttpClient: f.HttpClient,
+		IO:         f.IOStreams,
+	}
+
+	cmd := &cobra.Command{
+		Use:     "list",
+		Short:   "List labels in a repository",
+		Long:    "Display labels in a GitHub repository.",
+		Args:    cobra.NoArgs,
+		Aliases: []string{"ls"},
+		RunE: func(c *cobra.Command, args []string) error {
+			// support `-R, --repo` override
+			opts.BaseRepo = f.BaseRepo
+
+			if opts.Limit < 1 {
+				return cmdutil.FlagErrorf("invalid limit: %v", opts.Limit)
+			}
+
+			if runF != nil {
+				return runF(&opts)
+			}
+			return listRun(&opts)
+		},
+	}
+
+	cmd.Flags().BoolVarP(&opts.WebMode, "web", "w", false, "List labels in the web browser")
+	cmd.Flags().IntVarP(&opts.Limit, "limit", "L", 30, "Maximum number of items to fetch")
+
+	return cmd
+}
+
+func listRun(opts *ListOptions) error {
+	httpClient, err := opts.HttpClient()
+	if err != nil {
+		return err
+	}
+
+	baseRepo, err := opts.BaseRepo()
+	if err != nil {
+		return err
+	}
+
+	if opts.WebMode {
+		labelListURL := ghrepo.GenerateRepoURL(baseRepo, "labels")
+
+		if opts.IO.IsStdoutTTY() {
+			fmt.Fprintf(opts.IO.ErrOut, "Opening %s in your browser.\n", utils.DisplayURL(labelListURL))
+		}
+
+		return opts.Browser.Browse(labelListURL)
+	}
+
+	opts.IO.StartProgressIndicator()
+	labels, totalCount, err := listLabels(httpClient, baseRepo, opts.Limit)
+	opts.IO.StopProgressIndicator()
+	if err != nil {
+		return err
+	}
+
+	if opts.IO.IsStdoutTTY() {
+		title := listHeader(ghrepo.FullName(baseRepo), len(labels), totalCount)
+		fmt.Fprintf(opts.IO.Out, "\n%s\n\n", title)
+	}
+
+	return printLabels(opts.IO, labels)
+}
+
+func printLabels(io *iostreams.IOStreams, labels []shared.Label) error {
+	cs := io.ColorScheme()
+	table := utils.NewTablePrinter(io)
+
+	for _, label := range labels {
+		labelName := ""
+		if table.IsTTY() {
+			labelName = cs.HexToRGB(label.Color, label.Name)
+		} else {
+			labelName = label.Name
+		}
+
+		table.AddField(labelName, nil, nil)
+		table.AddField(label.Description, nil, nil)
+
+		table.EndRow()
+	}
+
+	return table.Render()
+}
+
+func listHeader(repoName string, count int, totalCount int) string {
+	if totalCount == 0 {
+		return fmt.Sprintf("There are no %ss in %s", "label", repoName)
+	}
+
+	return fmt.Sprintf("Showing %d of %s in %s", count, utils.Pluralize(totalCount, "label"), repoName)
+}

pkg/cmd/label/list/list_test.go

@@ -0,0 +1,210 @@
+package list
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/httpmock"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewCmdList(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		output  ListOptions
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name:   "no argument",
+			input:  "",
+			output: ListOptions{Limit: 30},
+		},
+		{
+			name:   "limit flag",
+			input:  "--limit 10",
+			output: ListOptions{Limit: 10},
+		},
+		{
+			name:    "invalid limit flag",
+			input:   "--limit 0",
+			wantErr: true,
+			errMsg:  "invalid limit: 0",
+		},
+		{
+			name:   "web flag",
+			input:  "--web",
+			output: ListOptions{Limit: 30, WebMode: true},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			io, _, _, _ := iostreams.Test()
+			f := &cmdutil.Factory{
+				IOStreams: io,
+			}
+			argv, err := shlex.Split(tt.input)
+			assert.NoError(t, err)
+			var gotOpts *ListOptions
+			cmd := NewCmdList(f, func(opts *ListOptions) error {
+				gotOpts = opts
+				return nil
+			})
+			cmd.SetArgs(argv)
+			cmd.SetIn(&bytes.Buffer{})
+			cmd.SetOut(&bytes.Buffer{})
+			cmd.SetErr(&bytes.Buffer{})
+
+			_, err = cmd.ExecuteC()
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.errMsg)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.output.Limit, gotOpts.Limit)
+			assert.Equal(t, tt.output.WebMode, gotOpts.WebMode)
+		})
+	}
+}
+
+func TestListRun(t *testing.T) {
+	tests := []struct {
+		name       string
+		tty        bool
+		opts       *ListOptions
+		httpStubs  func(*httpmock.Registry)
+		wantStdout string
+		wantStderr string
+	}{
+		{
+			name: "lists labels",
+			tty:  true,
+			opts: &ListOptions{},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.GraphQL(`query LabelList\b`),
+					httpmock.StringResponse(`
+						{
+							"data": {
+								"repository": {
+									"labels": {
+										"totalCount": 2,
+										"nodes": [
+											{
+												"name": "bug",
+												"color": "d73a4a",
+												"description": "This is a bug label"
+											},
+											{
+												"name": "docs",
+												"color": "ffa8da",
+												"description": "This is a docs label"
+											}
+										],
+										"pageInfo": {
+											"hasNextPage": false,
+											"endCursor": "Y3Vyc29yOnYyOpK5MjAxOS0xMC0xMVQwMTozODowMyswODowMM5f3HZq"
+										}
+									}
+								}
+							}
+						}`,
+					),
+				)
+			},
+			wantStdout: "\nShowing 2 of 2 labels in OWNER/REPO\n\nbug   This is a bug label\ndocs  This is a docs label\n",
+		},
+		{
+			name: "lists labels notty",
+			tty:  false,
+			opts: &ListOptions{},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.GraphQL(`query LabelList\b`),
+					httpmock.StringResponse(`
+						{
+							"data": {
+								"repository": {
+									"labels": {
+										"totalCount": 2,
+										"nodes": [
+											{
+												"name": "bug",
+												"color": "d73a4a",
+												"description": "This is a bug label"
+											},
+											{
+												"name": "docs",
+												"color": "ffa8da",
+												"description": "This is a docs label"
+											}
+										],
+										"pageInfo": {
+											"hasNextPage": false,
+											"endCursor": "Y3Vyc29yOnYyOpK5MjAxOS0xMC0xMVQwMTozODowMyswODowMM5f3HZq"
+										}
+									}
+								}
+							}
+						}`,
+					),
+				)
+			},
+			wantStdout: "bug\tThis is a bug label\ndocs\tThis is a docs label\n",
+		},
+		{
+			name: "empty label list",
+			tty:  true,
+			opts: &ListOptions{},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.GraphQL(`query LabelList\b`),
+					httpmock.StringResponse(`
+						{"data":{"repository":{"labels":{"totalCount":0,"nodes":[],"pageInfo":{"hasNextPage":false,"endCursor":null}}}}}`,
+					),
+				)
+			},
+			wantStdout: "\nThere are no labels in OWNER/REPO\n\n",
+		},
+		{
+			name:       "web mode",
+			tty:        true,
+			opts:       &ListOptions{WebMode: true},
+			wantStderr: "Opening github.com/OWNER/REPO/labels in your browser.\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reg := &httpmock.Registry{}
+			if tt.httpStubs != nil {
+				tt.httpStubs(reg)
+			}
+			tt.opts.HttpClient = func() (*http.Client, error) {
+				return &http.Client{Transport: reg}, nil
+			}
+			io, _, stdout, stderr := iostreams.Test()
+			io.SetStdoutTTY(tt.tty)
+			io.SetStdinTTY(tt.tty)
+			io.SetStderrTTY(tt.tty)
+			tt.opts.IO = io
+			tt.opts.Browser = &cmdutil.TestBrowser{}
+			tt.opts.BaseRepo = func() (ghrepo.Interface, error) {
+				return ghrepo.New("OWNER", "REPO"), nil
+			}
+			defer reg.Verify(t)
+			err := listRun(tt.opts)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.wantStdout, stdout.String())
+			assert.Equal(t, tt.wantStderr, stderr.String())
+		})
+	}
+}

pkg/cmd/label/shared/shared.go

@@ -0,0 +1,7 @@
+package shared
+
+type Label struct {
+	Name        string
+	Color       string
+	Description string
+}

pkg/cmd/root/root.go

@@ -20,6 +20,7 @@ import (
 	gistCmd "github.com/cli/cli/v2/pkg/cmd/gist"
 	gpgKeyCmd "github.com/cli/cli/v2/pkg/cmd/gpg-key"
 	issueCmd "github.com/cli/cli/v2/pkg/cmd/issue"
+	labelCmd "github.com/cli/cli/v2/pkg/cmd/label"
 	prCmd "github.com/cli/cli/v2/pkg/cmd/pr"
 	releaseCmd "github.com/cli/cli/v2/pkg/cmd/release"
 	repoCmd "github.com/cli/cli/v2/pkg/cmd/repo"
@@ -104,6 +105,7 @@ func NewCmdRoot(f *cmdutil.Factory, version, buildDate string) *cobra.Command {
 	cmd.AddCommand(repoCmd.NewCmdRepo(&repoResolvingCmdFactory))
 	cmd.AddCommand(runCmd.NewCmdRun(&repoResolvingCmdFactory))
 	cmd.AddCommand(workflowCmd.NewCmdWorkflow(&repoResolvingCmdFactory))
+	cmd.AddCommand(labelCmd.NewCmdLabel(&repoResolvingCmdFactory))
 
 	// Help topics
 	cmd.AddCommand(NewHelpTopic("environment"))

pkg/cmdutil/args.go

@@ -21,7 +21,6 @@ func MinimumArgs(n int, msg string) cobra.PositionalArgs {
 }
 
 func ExactArgs(n int, msg string) cobra.PositionalArgs {
-
 	return func(cmd *cobra.Command, args []string) error {
 		if len(args) > n {
 			return FlagErrorf("too many arguments")