STACKITGit/cli
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'origin/trunk' into feature/shell-completion-bundled-on-release

Browse source
This commit is contained in:
nate smith 2023-04-20 12:13:02 -07:00
commit 65a8ab25df
58 changed files with 1333 additions and 140 deletions
Download patch file Download diff file Expand all files Collapse all files

25
.github/workflows/deployment.yml vendored Normal file
View file

@ -0,0 +1,25 @@
name: Deployment
permissions:
contents: read
on:
workflow_dispatch:
inputs:
tag_name:
required: true
type: string
go_version:
default: "1.19"
type: string
jobs:
linux:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Set up Go
uses: actions/setup-go@v4
with:
go-version: ${{ inputs.go_version }}

27
api/client.go
View file

@ -11,8 +11,7 @@ import (
"strings"
"github.com/cli/cli/v2/internal/ghinstance"
"github.com/cli/go-gh"
ghAPI "github.com/cli/go-gh/pkg/api"
ghAPI "github.com/cli/go-gh/v2/pkg/api"
)
const (
@ -40,11 +39,11 @@ func (c *Client) HTTP() *http.Client {
}
type GraphQLError struct {
ghAPI.GQLError
*ghAPI.GraphQLError
}
type HTTPError struct {
ghAPI.HTTPError
*ghAPI.HTTPError
scopesSuggestion string
}
@ -57,7 +56,7 @@ func (err HTTPError) ScopesSuggestion() string {
func (c Client) GraphQL(hostname string, query string, variables map[string]interface{}, data interface{}) error {
opts := clientOptions(hostname, c.http.Transport)
opts.Headers[graphqlFeatures] = features
gqlClient, err := gh.GQLClient(&opts)
gqlClient, err := ghAPI.NewGraphQLClient(opts)
if err != nil {
return err
}
@ -69,7 +68,7 @@ func (c Client) GraphQL(hostname string, query string, variables map[string]inte
func (c Client) Mutate(hostname, name string, mutation interface{}, variables map[string]interface{}) error {
opts := clientOptions(hostname, c.http.Transport)
opts.Headers[graphqlFeatures] = features
gqlClient, err := gh.GQLClient(&opts)
gqlClient, err := ghAPI.NewGraphQLClient(opts)
if err != nil {
return err
}
@ -81,7 +80,7 @@ func (c Client) Mutate(hostname, name string, mutation interface{}, variables ma
func (c Client) Query(hostname, name string, query interface{}, variables map[string]interface{}) error {
opts := clientOptions(hostname, c.http.Transport)
opts.Headers[graphqlFeatures] = features
gqlClient, err := gh.GQLClient(&opts)
gqlClient, err := ghAPI.NewGraphQLClient(opts)
if err != nil {
return err
}
@ -93,7 +92,7 @@ func (c Client) Query(hostname, name string, query interface{}, variables map[st
func (c Client) QueryWithContext(ctx context.Context, hostname, name string, query interface{}, variables map[string]interface{}) error {
opts := clientOptions(hostname, c.http.Transport)
opts.Headers[graphqlFeatures] = features
gqlClient, err := gh.GQLClient(&opts)
gqlClient, err := ghAPI.NewGraphQLClient(opts)
if err != nil {
return err
}
@ -103,7 +102,7 @@ func (c Client) QueryWithContext(ctx context.Context, hostname, name string, que
// REST performs a REST request and parses the response.
func (c Client) REST(hostname string, method string, p string, body io.Reader, data interface{}) error {
opts := clientOptions(hostname, c.http.Transport)
restClient, err := gh.RESTClient(&opts)
restClient, err := ghAPI.NewRESTClient(opts)
if err != nil {
return err
}
@ -112,7 +111,7 @@ func (c Client) REST(hostname string, method string, p string, body io.Reader, d
func (c Client) RESTWithNext(hostname string, method string, p string, body io.Reader, data interface{}) (string, error) {
opts := clientOptions(hostname, c.http.Transport)
restClient, err := gh.RESTClient(&opts)
restClient, err := ghAPI.NewRESTClient(opts)
if err != nil {
return "", err
}
@ -157,14 +156,14 @@ func HandleHTTPError(resp *http.Response) error {
return handleResponse(ghAPI.HandleHTTPError(resp))
}
// handleResponse takes a ghAPI.HTTPError or ghAPI.GQLError and converts it into an
// handleResponse takes a ghAPI.HTTPError or ghAPI.GraphQLError and converts it into an
// HTTPError or GraphQLError respectively.
func handleResponse(err error) error {
if err == nil {
return nil
}
var restErr ghAPI.HTTPError
var restErr *ghAPI.HTTPError
if errors.As(err, &restErr) {
return HTTPError{
HTTPError: restErr,
@ -175,10 +174,10 @@ func handleResponse(err error) error {
}
}
var gqlErr ghAPI.GQLError
var gqlErr *ghAPI.GraphQLError
if errors.As(err, &gqlErr) {
return GraphQLError{
GQLError: gqlErr,
GraphQLError: gqlErr,
}
}

5
api/http_client.go
View file

@ -9,8 +9,7 @@ import (
"github.com/cli/cli/v2/internal/ghinstance"
"github.com/cli/cli/v2/utils"
"github.com/cli/go-gh"
ghAPI "github.com/cli/go-gh/pkg/api"
ghAPI "github.com/cli/go-gh/v2/pkg/api"
)
type tokenGetter interface {
@ -55,7 +54,7 @@ func NewHTTPClient(opts HTTPClientOptions) (*http.Client, error) {
clientOpts.CacheTTL = opts.CacheTTL
}
client, err := gh.HTTPClient(&clientOpts)
client, err := ghAPI.NewHTTPClient(clientOpts)
if err != nil {
return nil, err
}

2
api/queries_projects_v2.go
View file

@ -255,7 +255,7 @@ func CurrentUserProjectsV2(client *Client, hostname string) ([]ProjectV2, error)
// When querying ProjectsV2 fields we generally dont want to show the user
// scope errors and field does not exist errors. ProjectsV2IgnorableError
// checks against known error strings to see if an error can be safely ignored.
// Due to the fact that the GQLClient can return multiple types of errors
// Due to the fact that the GraphQLClient can return multiple types of errors
// this uses brittle string comparison to check against the known error strings.
func ProjectsV2IgnorableError(err error) bool {
msg := err.Error()

10
api/queries_repo.go
View file

@ -16,7 +16,7 @@ import (
"golang.org/x/sync/errgroup"
"github.com/cli/cli/v2/internal/ghrepo"
ghAPI "github.com/cli/go-gh/pkg/api"
ghAPI "github.com/cli/go-gh/v2/pkg/api"
"github.com/shurcooL/githubv4"
)
@ -263,8 +263,8 @@ func FetchRepository(client *Client, repo ghrepo.Interface, fields []string) (*R
// guaranteed to happen when an authentication token with insufficient permissions is being used.
if result.Repository == nil {
return nil, GraphQLError{
GQLError: ghAPI.GQLError{
Errors: []ghAPI.GQLErrorItem{{
GraphQLError: &ghAPI.GraphQLError{
Errors: []ghAPI.GraphQLErrorItem{{
Type: "NOT_FOUND",
Message: fmt.Sprintf("Could not resolve to a Repository with the name '%s/%s'.", repo.RepoOwner(), repo.RepoName()),
}},
@ -316,8 +316,8 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
// guaranteed to happen when an authentication token with insufficient permissions is being used.
if result.Repository == nil {
return nil, GraphQLError{
GQLError: ghAPI.GQLError{
Errors: []ghAPI.GQLErrorItem{{
GraphQLError: &ghAPI.GraphQLError{
Errors: []ghAPI.GraphQLErrorItem{{
Type: "NOT_FOUND",
Message: fmt.Sprintf("Could not resolve to a Repository with the name '%s/%s'.", repo.RepoOwner(), repo.RepoName()),
}},

6
go.mod
View file

@ -6,10 +6,10 @@ require (
github.com/AlecAivazis/survey/v2 v2.3.6
github.com/MakeNowJust/heredoc v1.0.0
github.com/briandowns/spinner v1.18.1
github.com/cenkalti/backoff/v4 v4.2.0
github.com/cenkalti/backoff/v4 v4.2.1
github.com/charmbracelet/glamour v0.5.1-0.20220727184942-e70ff2d969da
github.com/charmbracelet/lipgloss v0.5.0
github.com/cli/go-gh v1.2.1
github.com/cli/go-gh/v2 v2.0.0
github.com/cli/oauth v1.0.1
github.com/cli/safeexec v1.0.1
github.com/cpuguy83/go-md2man/v2 v2.0.2
@ -50,7 +50,7 @@ require (
github.com/alessio/shellescape v1.4.1 // indirect
github.com/aymerick/douceur v0.2.0 // indirect
github.com/cli/browser v1.1.0 // indirect
github.com/cli/shurcooL-graphql v0.0.2 // indirect
github.com/cli/shurcooL-graphql v0.0.3 // indirect
github.com/danieljoos/wincred v1.1.2 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dlclark/regexp2 v1.4.0 // indirect

12
go.sum
View file

@ -47,8 +47,8 @@ github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuP
github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
github.com/briandowns/spinner v1.18.1 h1:yhQmQtM1zsqFsouh09Bk/jCjd50pC3EOGsh28gLVvwY=
github.com/briandowns/spinner v1.18.1/go.mod h1:mQak9GHqbspjC/5iUx3qMlIho8xBS/ppAL/hX5SmPJU=
github.com/cenkalti/backoff/v4 v4.2.0 h1:HN5dHm3WBOgndBH6E8V0q2jIYIR3s9yglV8k/+MN3u4=
github.com/cenkalti/backoff/v4 v4.2.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/charmbracelet/glamour v0.5.1-0.20220727184942-e70ff2d969da h1:FGz53GWQRiKQ/5xUsoCCkewSQIC7u81Scaxx2nUy3nM=
github.com/charmbracelet/glamour v0.5.1-0.20220727184942-e70ff2d969da/go.mod h1:HXz79SMFnF9arKxqeoHWxmo1BhplAH7wehlRhKQIL94=
@ -62,15 +62,15 @@ github.com/cli/browser v1.1.0 h1:xOZBfkfY9L9vMBgqb1YwRirGu6QFaQ5dP/vXt5ENSOY=
github.com/cli/browser v1.1.0/go.mod h1:HKMQAt9t12kov91Mn7RfZxyJQQgWgyS/3SZswlZ5iTI=
github.com/cli/crypto v0.0.0-20210929142629-6be313f59b03 h1:3f4uHLfWx4/WlnMPXGai03eoWAI+oGHJwr+5OXfxCr8=
github.com/cli/crypto v0.0.0-20210929142629-6be313f59b03/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
github.com/cli/go-gh v1.2.1 h1:xFrjejSsgPiwXFP6VYynKWwxLQcNJy3Twbu82ZDlR/o=
github.com/cli/go-gh v1.2.1/go.mod h1:Jxk8X+TCO4Ui/GarwY9tByWm/8zp4jJktzVZNlTW5VM=
github.com/cli/go-gh/v2 v2.0.0 h1:JAgQY7VNHletsO0Eqr+/PzF7fF5QEjhY2t2+Tev3vmk=
github.com/cli/go-gh/v2 v2.0.0/go.mod h1:2/ox3Dnc8wDBT5bnTAH1aKGy6Qt1ztlFBe10EufnvoA=
github.com/cli/oauth v1.0.1 h1:pXnTFl/qUegXHK531Dv0LNjW4mLx626eS42gnzfXJPA=
github.com/cli/oauth v1.0.1/go.mod h1:qd/FX8ZBD6n1sVNQO3aIdRxeu5LGw9WhKnYhIIoC2A4=
github.com/cli/safeexec v1.0.0/go.mod h1:Z/D4tTN8Vs5gXYHDCbaM1S/anmEDnJb1iW0+EJ5zx3Q=
github.com/cli/safeexec v1.0.1 h1:e/C79PbXF4yYTN/wauC4tviMxEV13BwljGj0N9j+N00=
github.com/cli/safeexec v1.0.1/go.mod h1:Z/D4tTN8Vs5gXYHDCbaM1S/anmEDnJb1iW0+EJ5zx3Q=
github.com/cli/shurcooL-graphql v0.0.2 h1:rwP5/qQQ2fM0TzkUTwtt6E2LbIYf6R+39cUXTa04NYk=
github.com/cli/shurcooL-graphql v0.0.2/go.mod h1:tlrLmw/n5Q/+4qSvosT+9/W5zc8ZMjnJeYBxSdb4nWA=
github.com/cli/shurcooL-graphql v0.0.3 h1:CtpPxyGDs136/+ZeyAfUKYmcQBjDlq5aqnrDCW5Ghh8=
github.com/cli/shurcooL-graphql v0.0.3/go.mod h1:tlrLmw/n5Q/+4qSvosT+9/W5zc8ZMjnJeYBxSdb4nWA=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=

4
internal/browser/browser.go
View file

@ -3,7 +3,7 @@ package browser
import (
"io"
ghBrowser "github.com/cli/go-gh/pkg/browser"
ghBrowser "github.com/cli/go-gh/v2/pkg/browser"
)
type Browser interface {
@ -12,5 +12,5 @@ type Browser interface {
func New(launcher string, stdout, stderr io.Writer) Browser {
b := ghBrowser.New(launcher, stdout, stderr)
return &b
return b
}

11
internal/codespaces/codespaces.go
View file

@ -88,9 +88,14 @@ func ConnectToLiveshare(ctx context.Context, progress progressIndicator, session
})
}
// ListenTCP starts a localhost tcp listener and returns the listener and bound port
func ListenTCP(port int) (*net.TCPListener, int, error) {
addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("127.0.0.1:%d", port))
// ListenTCP starts a localhost tcp listener on 127.0.0.1 (unless allInterfaces is true) and returns the listener and bound port
func ListenTCP(port int, allInterfaces bool) (*net.TCPListener, int, error) {
host := "127.0.0.1"
if allInterfaces {
host = ""
}
addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", host, port))
if err != nil {
return nil, 0, fmt.Errorf("failed to build tcp address: %w", err)
}

1
internal/codespaces/rpc/invoker.go
View file

@ -239,6 +239,7 @@ func (i *invoker) StartSSHServerWithOptions(ctx context.Context, options StartSS
}
func listenTCP() (*net.TCPListener, error) {
// We will end up using this same address to connect, so specify the IP also or the connect will fail
addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
if err != nil {
return nil, fmt.Errorf("failed to build tcp address: %w", err)

2
internal/codespaces/states.go
View file

@ -52,7 +52,7 @@ func PollPostCreateStates(ctx context.Context, progress progressIndicator, apiCl
}()
// Ensure local port is listening before client (getPostCreateOutput) connects.
listen, localPort, err := ListenTCP(0)
listen, localPort, err := ListenTCP(0, false)
if err != nil {
return err
}

4
internal/config/config.go
View file

@ -4,8 +4,8 @@ import (
"os"
"path/filepath"
ghAuth "github.com/cli/go-gh/pkg/auth"
ghConfig "github.com/cli/go-gh/pkg/config"
ghAuth "github.com/cli/go-gh/v2/pkg/auth"
ghConfig "github.com/cli/go-gh/v2/pkg/config"
"github.com/zalando/go-keyring"
)

2
internal/config/stub.go
View file

@ -6,7 +6,7 @@ import (
"path/filepath"
"testing"
ghConfig "github.com/cli/go-gh/pkg/config"
ghConfig "github.com/cli/go-gh/v2/pkg/config"
)
func NewBlankConfig() *ConfigMock {

6
internal/ghrepo/repo.go
View file

@ -6,8 +6,8 @@ import (
"strings"
"github.com/cli/cli/v2/internal/ghinstance"
ghAuth "github.com/cli/go-gh/pkg/auth"
"github.com/cli/go-gh/pkg/repository"
ghAuth "github.com/cli/go-gh/v2/pkg/auth"
"github.com/cli/go-gh/v2/pkg/repository"
)
// Interface describes an object that represents a GitHub repository
@ -54,7 +54,7 @@ func FromFullNameWithHost(nwo, fallbackHost string) (Interface, error) {
if err != nil {
return nil, err
}
return NewWithHost(repo.Owner(), repo.Name(), repo.Host()), nil
return NewWithHost(repo.Owner, repo.Name, repo.Host), nil
}
// FromURL extracts the GitHub repository information from a git remote URL

2
internal/tableprinter/table_printer.go
View file

@ -6,7 +6,7 @@ import (
"github.com/cli/cli/v2/internal/text"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/go-gh/pkg/tableprinter"
"github.com/cli/go-gh/v2/pkg/tableprinter"
)
type TablePrinter struct {

2
internal/text/text.go
View file

@ -7,7 +7,7 @@ import (
"strings"
"time"
"github.com/cli/go-gh/pkg/text"
"github.com/cli/go-gh/v2/pkg/text"
"golang.org/x/text/cases"
"golang.org/x/text/language"
)

6
pkg/cmd/api/api.go
View file

@ -23,8 +23,8 @@ import (
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/cli/v2/pkg/jsoncolor"
"github.com/cli/go-gh/pkg/jq"
"github.com/cli/go-gh/pkg/template"
"github.com/cli/go-gh/v2/pkg/jq"
"github.com/cli/go-gh/v2/pkg/template"
"github.com/spf13/cobra"
)
@ -328,7 +328,7 @@ func apiRun(opts *ApiOptions) error {
return err
}
endCursor, err := processResponse(resp, opts, bodyWriter, headersWriter, &tmpl)
endCursor, err := processResponse(resp, opts, bodyWriter, headersWriter, tmpl)
if err != nil {
return err
}

4
pkg/cmd/api/api_test.go
View file

@ -19,7 +19,7 @@ import (
"github.com/cli/cli/v2/internal/ghrepo"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/go-gh/pkg/template"
"github.com/cli/go-gh/v2/pkg/template"
"github.com/google/shlex"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -1206,7 +1206,7 @@ func Test_processResponse_template(t *testing.T) {
tmpl := template.New(ios.Out, ios.TerminalWidth(), ios.ColorEnabled())
err := tmpl.Parse(opts.Template)
require.NoError(t, err)
_, err = processResponse(&resp, &opts, ios.Out, io.Discard, &tmpl)
_, err = processResponse(&resp, &opts, ios.Out, io.Discard, tmpl)
require.NoError(t, err)
err = tmpl.Flush()
require.NoError(t, err)

7
pkg/cmd/auth/login/login.go
View file

@ -14,7 +14,7 @@ import (
"github.com/cli/cli/v2/pkg/cmd/auth/shared"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
ghAuth "github.com/cli/go-gh/pkg/auth"
ghAuth "github.com/cli/go-gh/v2/pkg/auth"
"github.com/spf13/cobra"
)
@ -151,6 +151,11 @@ func loginRun(opts *LoginOptions) error {
}
}
// The go-gh Config object currently does not support case-insensitive lookups for host names,
// so normalize the host name case here before performing any lookups with it or persisting it.
// https://github.com/cli/go-gh/pull/105
hostname = strings.ToLower(hostname)
if src, writeable := shared.AuthTokenWriteable(authCfg, hostname); !writeable {
fmt.Fprintf(opts.IO.ErrOut, "The value of the %s environment variable is being used for authentication.\n", src)
fmt.Fprint(opts.IO.ErrOut, "To have GitHub CLI store credentials instead, first clear the value from the environment.\n")

39
pkg/cmd/codespace/create.go
View file

@ -69,6 +69,7 @@ type createOptions struct {
idleTimeout time.Duration
retentionPeriod NullableDuration
displayName string
useWeb bool
}
func newCreateCmd(app *App) *cobra.Command {
@ -78,11 +79,20 @@ func newCreateCmd(app *App) *cobra.Command {
Use: "create",
Short: "Create a codespace",
Args: noArgsConstraint,
PreRunE: func(cmd *cobra.Command, args []string) error {
return cmdutil.MutuallyExclusive(
"using --web with --display-name, --idle-timeout, or --retention-period is not supported",
opts.useWeb,
opts.displayName != "" || opts.idleTimeout != 0 || opts.retentionPeriod.Duration != nil,
)
},
RunE: func(cmd *cobra.Command, args []string) error {
return app.Create(cmd.Context(), opts)
},
}
createCmd.Flags().BoolVarP(&opts.useWeb, "web", "w", false, "create codespace from browser, cannot be used with --display-name, --idle-timeout, or --retention-period")
createCmd.Flags().StringVarP(&opts.repo, "repo", "R", "", "repository name with owner: user/repo")
if err := addDeprecatedRepoShorthand(createCmd, &opts.repo); err != nil {
fmt.Fprintf(app.io.ErrOut, "%v\n", err)
@ -118,7 +128,11 @@ func (a *App) Create(ctx context.Context, opts createOptions) error {
Location: opts.location,
}
promptForRepoAndBranch := userInputs.Repository == ""
if opts.useWeb && userInputs.Repository == "" {
return a.browser.Browse("https://github.com/codespaces/new")
}
promptForRepoAndBranch := userInputs.Repository == "" && !opts.useWeb
if promptForRepoAndBranch {
var defaultRepo string
if remotes, _ := a.remotes(); remotes != nil {
@ -249,12 +263,19 @@ func (a *App) Create(ctx context.Context, opts createOptions) error {
}
}
machine, err := getMachineName(ctx, a.apiClient, repository.ID, opts.machine, branch, userInputs.Location, devContainerPath)
if err != nil {
return fmt.Errorf("error getting machine type: %w", err)
}
if machine == "" {
return errors.New("there are no available machine types for this repository")
machine := opts.machine
// skip this if we have useWeb and no machine name provided,
// because web UI will select default machine type if none is provided
// web UI also provide a way to select machine type
// therefore we let the user choose from the web UI instead of prompting from CLI
if !(opts.useWeb && opts.machine == "") {
machine, err = getMachineName(ctx, a.apiClient, repository.ID, opts.machine, branch, userInputs.Location, devContainerPath)
if err != nil {
return fmt.Errorf("error getting machine type: %w", err)
}
if machine == "" {
return errors.New("there are no available machine types for this repository")
}
}
createParams := &api.CreateCodespaceParams{
@ -271,6 +292,10 @@ func (a *App) Create(ctx context.Context, opts createOptions) error {
DisplayName: opts.displayName,
}
if opts.useWeb {
return a.browser.Browse(fmt.Sprintf("https://github.com/codespaces/new?repo=%d&ref=%s&machine=%s&location=%s", createParams.RepositoryID, createParams.Branch, createParams.Machine, createParams.Location))
}
var codespace *api.Codespace
err = a.RunWithProgress("Creating codespace", func() (err error) {
codespace, err = a.apiClient.CreateCodespace(ctx, createParams)

176
pkg/cmd/codespace/create_test.go
View file

@ -1,17 +1,60 @@
package codespace
import (
"bytes"
"context"
"fmt"
"testing"
"time"
"github.com/cli/cli/v2/internal/browser"
"github.com/cli/cli/v2/internal/codespaces/api"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/google/shlex"
"github.com/stretchr/testify/assert"
)
func TestCreateCmdFlagError(t *testing.T) {
tests := []struct {
name string
args string
wantsErr error
}{
{
name: "return error when using web flag with display-name, idle-timeout, or retention-period flags",
args: "--web --display-name foo --idle-timeout 30m",
wantsErr: fmt.Errorf("using --web with --display-name, --idle-timeout, or --retention-period is not supported"),
},
{
name: "return error when using web flag with one of display-name, idle-timeout or retention-period flags",
args: "--web --idle-timeout 30m",
wantsErr: fmt.Errorf("using --web with --display-name, --idle-timeout, or --retention-period is not supported"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, _, _ := iostreams.Test()
a := &App{
io: ios,
}
cmd := newCreateCmd(a)
args, _ := shlex.Split(tt.args)
cmd.SetArgs(args)
cmd.SetIn(&bytes.Buffer{})
cmd.SetOut(&bytes.Buffer{})
cmd.SetErr(&bytes.Buffer{})
_, err := cmd.ExecuteC()
assert.Error(t, err)
assert.EqualError(t, err, tt.wantsErr.Error())
})
}
}
func TestApp_Create(t *testing.T) {
type fields struct {
apiClient apiClient
@ -23,6 +66,7 @@ func TestApp_Create(t *testing.T) {
wantErr error
wantStdout string
wantStderr string
wantURL string
isTTY bool
}{
{
@ -115,6 +159,31 @@ func TestApp_Create(t *testing.T) {
wantStdout: "monalisa-dotfiles-abcd1234\n",
wantStderr: " ✓ Codespaces usage for this repository is paid for by monalisa\n",
},
{
name: "create codespace with nonexistent machine results in error",
fields: fields{
apiClient: apiCreateDefaults(&apiClientMock{
GetCodespacesMachinesFunc: func(ctx context.Context, repoID int, branch, location string, devcontainerPath string) ([]*api.Machine, error) {
return []*api.Machine{
{
Name: "GIGA",
DisplayName: "Gigabits of a machine",
},
{
Name: "TERA",
DisplayName: "Terabits of a machine",
},
}, nil
},
}),
},
opts: createOptions{
repo: "monalisa/dotfiles",
machine: "MEGA",
},
wantStderr: " ✓ Codespaces usage for this repository is paid for by monalisa\n",
wantErr: fmt.Errorf("error getting machine type: there is no such machine for the repository: %s\nAvailable machines: %v", "MEGA", []string{"GIGA", "TERA"}),
},
{
name: "create codespace with devcontainer path results in selecting the correct machine type",
fields: fields{
@ -382,7 +451,95 @@ Alternatively, you can run "create" with the "--default-permissions" option to c
},
wantStdout: "megacorp-private-abcd1234\n",
},
{
name: "return default url when using web flag without other flags",
opts: createOptions{
useWeb: true,
},
wantURL: "https://github.com/codespaces/new",
},
{
name: "skip machine check when using web flag and no machine provided",
fields: fields{
apiClient: apiCreateDefaults(&apiClientMock{
GetRepositoryFunc: func(ctx context.Context, nwo string) (*api.Repository, error) {
return &api.Repository{
ID: 123,
DefaultBranch: "main",
}, nil
},
CreateCodespaceFunc: func(ctx context.Context, params *api.CreateCodespaceParams) (*api.Codespace, error) {
return &api.Codespace{
Name: "monalisa-dotfiles-abcd1234",
}, nil
},
}),
},
opts: createOptions{
repo: "monalisa/dotfiles",
useWeb: true,
branch: "custom",
location: "EastUS",
},
wantStderr: " ✓ Codespaces usage for this repository is paid for by monalisa\n",
wantURL: fmt.Sprintf("https://github.com/codespaces/new?repo=%d&ref=%s&machine=%s&location=%s", 123, "custom", "", "EastUS"),
},
{
name: "return correct url with correct params when using web flag and repo flag",
fields: fields{
apiClient: apiCreateDefaults(&apiClientMock{
GetRepositoryFunc: func(ctx context.Context, nwo string) (*api.Repository, error) {
return &api.Repository{
ID: 123,
DefaultBranch: "main",
}, nil
},
CreateCodespaceFunc: func(ctx context.Context, params *api.CreateCodespaceParams) (*api.Codespace, error) {
return &api.Codespace{
Name: "monalisa-dotfiles-abcd1234",
}, nil
},
}),
},
opts: createOptions{
repo: "monalisa/dotfiles",
useWeb: true,
},
wantStderr: " ✓ Codespaces usage for this repository is paid for by monalisa\n",
wantURL: fmt.Sprintf("https://github.com/codespaces/new?repo=%d&ref=%s&machine=%s&location=%s", 123, "main", "", ""),
},
{
name: "return correct url with correct params when using web flag, repo, branch, location, machine flag",
fields: fields{
apiClient: apiCreateDefaults(&apiClientMock{
GetRepositoryFunc: func(ctx context.Context, nwo string) (*api.Repository, error) {
return &api.Repository{
ID: 123,
DefaultBranch: "main",
}, nil
},
CreateCodespaceFunc: func(ctx context.Context, params *api.CreateCodespaceParams) (*api.Codespace, error) {
return &api.Codespace{
Name: "monalisa-dotfiles-abcd1234",
Machine: api.CodespaceMachine{Name: "GIGA"},
}, nil
},
}),
},
opts: createOptions{
repo: "monalisa/dotfiles",
machine: "GIGA",
branch: "custom",
location: "EastUS",
useWeb: true,
},
wantStderr: " ✓ Codespaces usage for this repository is paid for by monalisa\n",
wantURL: fmt.Sprintf("https://github.com/codespaces/new?repo=%d&ref=%s&machine=%s&location=%s", 123, "custom", "GIGA", "EastUS"),
},
}
var a *App
var b *browser.Stub
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, stdout, stderr := iostreams.Test()
@ -390,9 +547,18 @@ Alternatively, you can run "create" with the "--default-permissions" option to c
ios.SetStdinTTY(tt.isTTY)
ios.SetStderrTTY(tt.isTTY)
a := &App{
io: ios,
apiClient: tt.fields.apiClient,
if tt.opts.useWeb {
b = &browser.Stub{}
a = &App{
io: ios,
apiClient: tt.fields.apiClient,
browser: b,
}
} else {
a = &App{
io: ios,
apiClient: tt.fields.apiClient,
}
}
err := a.Create(context.Background(), tt.opts)
@ -410,6 +576,10 @@ Alternatively, you can run "create" with the "--default-permissions" option to c
t.Logf(t.Name())
t.Errorf(" stderr = %v, want %v", got, tt.wantStderr)
}
if tt.opts.useWeb {
b.Verify(t, tt.wantURL)
}
})
}
}

2
pkg/cmd/codespace/jupyter.go
View file

@ -67,7 +67,7 @@ func (a *App) Jupyter(ctx context.Context, selector *CodespaceSelector) (err err
}
// Pass 0 to pick a random port
listen, _, err := codespaces.ListenTCP(0)
listen, _, err := codespaces.ListenTCP(0, false)
if err != nil {
return err
}

34
pkg/cmd/codespace/list.go
View file

@ -18,6 +18,7 @@ type listOptions struct {
repo string
orgName string
userName string
useWeb bool
}
func newListCmd(app *App) *cobra.Command {
@ -34,11 +35,29 @@ func newListCmd(app *App) *cobra.Command {
`),
Aliases: []string{"ls"},
Args: noArgsConstraint,
RunE: func(cmd *cobra.Command, args []string) error {
PreRunE: func(cmd *cobra.Command, args []string) error {
if err := cmdutil.MutuallyExclusive(
"using `--org` or `--user` with `--repo` is not allowed",
opts.repo != "",
opts.orgName != "" || opts.userName != "",
); err != nil {
return err
}
if err := cmdutil.MutuallyExclusive(
"using `--web` with `--org` or `--user` is not supported, please use with `--repo` instead",
opts.useWeb,
opts.orgName != "" || opts.userName != "",
); err != nil {
return err
}
if opts.limit < 1 {
return cmdutil.FlagErrorf("invalid limit: %v", opts.limit)
}
return nil
},
RunE: func(cmd *cobra.Command, args []string) error {
return app.List(cmd.Context(), opts, exporter)
},
}
@ -53,13 +72,14 @@ func newListCmd(app *App) *cobra.Command {
listCmd.Flags().StringVarP(&opts.userName, "user", "u", "", "The `username` to list codespaces for (used with --org)")
cmdutil.AddJSONFlags(listCmd, &exporter, api.CodespaceFields)
listCmd.Flags().BoolVarP(&opts.useWeb, "web", "w", false, "List codespaces in the web browser, cannot be used with --user or --org")
return listCmd
}
func (a *App) List(ctx context.Context, opts *listOptions, exporter cmdutil.Exporter) error {
// if repo is provided, we don't accept orgName or userName
if opts.repo != "" && (opts.orgName != "" || opts.userName != "") {
return cmdutil.FlagErrorf("using `--org` or `--user` with `--repo` is not allowed")
if opts.useWeb && opts.repo == "" {
return a.browser.Browse("https://github.com/codespaces")
}
var codespaces []*api.Codespace
@ -92,6 +112,10 @@ func (a *App) List(ctx context.Context, opts *listOptions, exporter cmdutil.Expo
return cmdutil.NewNoResultsError("no codespaces found")
}
if opts.useWeb && codespaces[0].Repository.ID > 0 {
return a.browser.Browse(fmt.Sprintf("https://github.com/codespaces?repository_id=%d", codespaces[0].Repository.ID))
}
//nolint:staticcheck // SA1019: utils.NewTablePrinter is deprecated: use internal/tableprinter
tp := utils.NewTablePrinter(a.io)
if tp.IsTTY() {

118
pkg/cmd/codespace/list_test.go
View file

@ -1,15 +1,68 @@
package codespace
import (
"bytes"
"context"
"fmt"
"testing"
"github.com/cli/cli/v2/internal/browser"
"github.com/cli/cli/v2/internal/codespaces/api"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/google/shlex"
"github.com/stretchr/testify/assert"
)
func TestListCmdFlagError(t *testing.T) {
tests := []struct {
name string
args string
wantsErr error
}{
{
name: "list codespaces,--repo, --org and --user flag",
args: "--repo foo/bar --org github --user github",
wantsErr: fmt.Errorf("using `--org` or `--user` with `--repo` is not allowed"),
},
{
name: "list codespaces,--web, --org and --user flag",
args: "--web --org github --user github",
wantsErr: fmt.Errorf("using `--web` with `--org` or `--user` is not supported, please use with `--repo` instead"),
},
{
name: "list codespaces, negative --limit flag",
args: "--limit -1",
wantsErr: fmt.Errorf("invalid limit: -1"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, _, _ := iostreams.Test()
a := &App{
io: ios,
}
cmd := newListCmd(a)
args, _ := shlex.Split(tt.args)
cmd.SetArgs(args)
cmd.SetIn(&bytes.Buffer{})
cmd.SetOut(&bytes.Buffer{})
cmd.SetErr(&bytes.Buffer{})
_, err := cmd.ExecuteC()
if tt.wantsErr != nil {
assert.Error(t, err)
assert.EqualError(t, err, tt.wantsErr.Error())
return
}
})
}
}
func TestApp_List(t *testing.T) {
type fields struct {
apiClient apiClient
@ -19,6 +72,7 @@ func TestApp_List(t *testing.T) {
fields fields
opts *listOptions
wantError error
wantURL string
}{
{
name: "list codespaces, no flags",
@ -115,22 +169,66 @@ func TestApp_List(t *testing.T) {
},
},
{
name: "list codespaces,--repo, --org and --user flag",
name: "list codespaces,--web",
opts: &listOptions{
repo: "cli/cli",
orgName: "TestOrg",
userName: "jimmy",
useWeb: true,
},
wantError: fmt.Errorf("using `--org` or `--user` with `--repo` is not allowed"),
wantURL: "https://github.com/codespaces",
},
{
name: "list codespaces,--web, --repo flag",
fields: fields{
apiClient: &apiClientMock{
ListCodespacesFunc: func(ctx context.Context, opts api.ListCodespacesOptions) ([]*api.Codespace, error) {
if opts.RepoName == "" {
return nil, fmt.Errorf("Expected repository to not be nil")
}
if opts.RepoName != "cli/cli" {
return nil, fmt.Errorf("Expected repository name to be cli/cli. Got %s", opts.RepoName)
}
if opts.OrgName != "" {
return nil, fmt.Errorf("Expected orgName to be blank. Got %s", opts.OrgName)
}
if opts.UserName != "" {
return nil, fmt.Errorf("Expected userName to be blank. Got %s", opts.UserName)
}
return []*api.Codespace{
{
DisplayName: "CS1",
Repository: api.Repository{ID: 123},
},
}, nil
},
},
},
opts: &listOptions{
useWeb: true,
repo: "cli/cli",
},
wantURL: "https://github.com/codespaces?repository_id=123",
},
}
var b *browser.Stub
var a *App
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, _, _ := iostreams.Test()
a := &App{
io: ios,
apiClient: tt.fields.apiClient,
if tt.opts.useWeb {
b = &browser.Stub{}
a = &App{
browser: b,
io: ios,
apiClient: tt.fields.apiClient,
}
} else {
a = &App{
io: ios,
apiClient: tt.fields.apiClient,
}
}
var exporter cmdutil.Exporter
err := a.List(context.Background(), tt.opts, exporter)
@ -142,6 +240,10 @@ func TestApp_List(t *testing.T) {
if err != nil && err.Error() != tt.wantError.Error() {
t.Errorf("error = %v, wantErr %v", err, tt.wantError)
}
if tt.opts.useWeb {
b.Verify(t, tt.wantURL)
}
})
}
}

2
pkg/cmd/codespace/logs.go
View file

@ -49,7 +49,7 @@ func (a *App) Logs(ctx context.Context, selector *CodespaceSelector, follow bool
defer safeClose(session, &err)
// Ensure local port is listening before client (getPostCreateOutput) connects.
listen, localPort, err := codespaces.ListenTCP(0)
listen, localPort, err := codespaces.ListenTCP(0, false)
if err != nil {
return err
}

2
pkg/cmd/codespace/ports.go
View file

@ -379,7 +379,7 @@ func (a *App) ForwardPorts(ctx context.Context, selector *CodespaceSelector, por
for _, pair := range portPairs {
pair := pair
group.Go(func() error {
listen, _, err := codespaces.ListenTCP(pair.local)
listen, _, err := codespaces.ListenTCP(pair.local, true)
if err != nil {
return err
}

12
pkg/cmd/codespace/ssh.go
View file

@ -56,8 +56,14 @@ func newSSHCmd(app *App) *cobra.Command {
The 'ssh' command is used to SSH into a codespace. In its simplest form, you can
run 'gh cs ssh', select a codespace interactively, and connect.
By default, the 'ssh' command will create a public/private ssh key pair to
authenticate with the codespace inside the ~/.ssh directory.
The 'ssh' command will automatically create a public/private ssh key pair in the
~/.ssh directory if you do not have an existing valid key pair. When selecting the
key pair to use, the preferred order is:
1. Key specified by -i in <ssh-flags>
2. Automatic key, if it already exists
3. First valid key pair in ssh config (according to ssh -G)
4. Automatic key, newly created
The 'ssh' command also supports deeper integration with OpenSSH using a '--config'
option that generates per-codespace ssh configuration in OpenSSH format.
@ -205,7 +211,7 @@ func (a *App) SSH(ctx context.Context, sshArgs []string, opts sshOptions) (err e
// Ensure local port is listening before client (Shell) connects.
// Unless the user specifies a server port, localSSHServerPort is 0
// and thus the client will pick a random port.
listen, localSSHServerPort, err := codespaces.ListenTCP(localSSHServerPort)
listen, localSSHServerPort, err := codespaces.ListenTCP(localSSHServerPort, false)
if err != nil {
return err
}

2
pkg/cmd/codespace/stop.go
View file

@ -97,7 +97,7 @@ func (a *App) StopCodespace(ctx context.Context, opts *stopOptions) error {
}
}
err := a.RunWithProgress("Stoppping codespace", func() (err error) {
err := a.RunWithProgress("Stopping codespace", func() (err error) {
err = a.apiClient.StopCodespace(ctx, codespaceName, opts.orgName, ownerName)
return
})

2
pkg/cmd/extension/command.go
View file

@ -253,7 +253,7 @@ func NewCmdExtension(f *cmdutil.Factory) *cobra.Command {
// Qualifier flags
cmd.Flags().StringSliceVar(&qualifiers.License, "license", nil, "Filter based on license type")
cmd.Flags().StringVar(&qualifiers.User, "owner", "", "Filter on owner")
cmd.Flags().StringSliceVar(&qualifiers.User, "owner", nil, "Filter on owner")
return cmd
}(),

4
pkg/cmd/extension/ext_tmpls/goBinMain.go.txt
View file

@ -3,12 +3,12 @@ package main
import (
"fmt"
"github.com/cli/go-gh"
"github.com/cli/go-gh/v2/pkg/api"
)
func main() {
fmt.Println("hi world, this is the %s extension!")
client, err := gh.RESTClient(nil)
client, err := api.DefaultRESTClient()
if err != nil {
fmt.Println(err)
return

2
pkg/cmd/factory/remote_resolver.go
View file

@ -10,7 +10,7 @@ import (
"github.com/cli/cli/v2/internal/config"
"github.com/cli/cli/v2/internal/ghinstance"
"github.com/cli/cli/v2/pkg/set"
"github.com/cli/go-gh/pkg/ssh"
"github.com/cli/go-gh/v2/pkg/ssh"
)
const (

98
pkg/cmd/org/list/http.go Normal file
View file

@ -0,0 +1,98 @@
package list
import (
"net/http"
"github.com/cli/cli/v2/api"
)
type OrganizationList struct {
Organizations []Organization
TotalCount int
User string
}
type Organization struct {
Login string
}
func listOrgs(httpClient *http.Client, hostname string, limit int) (*OrganizationList, error) {
type response struct {
User struct {
Login string
Organizations struct {
TotalCount int
Nodes []Organization
PageInfo struct {
HasNextPage bool
EndCursor string
}
} `graphql:"organizations(first: $limit, after: $endCursor)"`
}
}
query := `query OrganizationList($user: String!, $limit: Int!, $endCursor: String) {
user(login: $user) {
login
organizations(first: $limit, after: $endCursor) {
totalCount
nodes {
login
}
pageInfo {
hasNextPage
endCursor
}
}
}
}`
client := api.NewClientFromHTTP(httpClient)
user, err := api.CurrentLoginName(client, hostname)
if err != nil {
return nil, err
}
listResult := OrganizationList{}
listResult.User = user
pageLimit := min(limit, 100)
variables := map[string]interface{}{
"user": user,
}
loop:
for {
variables["limit"] = pageLimit
var data response
err := client.GraphQL(hostname, query, variables, &data)
if err != nil {
return nil, err
}
listResult.TotalCount = data.User.Organizations.TotalCount
for _, org := range data.User.Organizations.Nodes {
listResult.Organizations = append(listResult.Organizations, org)
if len(listResult.Organizations) == limit {
break loop
}
}
if data.User.Organizations.PageInfo.HasNextPage {
variables["endCursor"] = data.User.Organizations.PageInfo.EndCursor
pageLimit = min(pageLimit, limit-len(listResult.Organizations))
} else {
break
}
}
return &listResult, nil
}
func min(a, b int) int {
if a < b {
return a
}
return b
}

83
pkg/cmd/org/list/http_test.go Normal file
View file

@ -0,0 +1,83 @@
package list
import (
"net/http"
"reflect"
"testing"
"github.com/cli/cli/v2/pkg/httpmock"
)
func Test_listOrgs(t *testing.T) {
type args struct {
limit int
}
tests := []struct {
name string
args args
httpStub func(*testing.T, *httpmock.Registry)
wantErr bool
}{
{
name: "default",
args: args{
limit: 30,
},
httpStub: func(t *testing.T, reg *httpmock.Registry) {
reg.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
reg.Register(
httpmock.GraphQL(`query OrganizationList\b`),
httpmock.GraphQLQuery(`{"data":{}}`, func(query string, vars map[string]interface{}) {
want := map[string]interface{}{
"user": "octocat",
"limit": float64(30),
}
if !reflect.DeepEqual(vars, want) {
t.Errorf("got GraphQL variables %#v, want %#v", vars, want)
}
}))
},
},
{
name: "with limit",
args: args{
limit: 1,
},
httpStub: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
r.Register(
httpmock.GraphQL(`query OrganizationList\b`),
httpmock.GraphQLQuery(`{"data":{}}`, func(query string, vars map[string]interface{}) {
want := map[string]interface{}{
"user": "octocat",
"limit": float64(1),
}
if !reflect.DeepEqual(vars, want) {
t.Errorf("got GraphQL variables %#v, want %#v", vars, want)
}
}))
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
reg := &httpmock.Registry{}
if tt.httpStub != nil {
tt.httpStub(t, reg)
}
httpClient := &http.Client{Transport: reg}
_, err := listOrgs(httpClient, "octocat", tt.args.limit)
if (err != nil) != tt.wantErr {
t.Errorf("listOrgs() error = %v, wantErr %v", err, tt.wantErr)
return
}
})
}
}

108
pkg/cmd/org/list/list.go Normal file
View file

@ -0,0 +1,108 @@
package list
import (
"fmt"
"net/http"
"github.com/MakeNowJust/heredoc"
"github.com/cli/cli/v2/internal/config"
"github.com/cli/cli/v2/internal/tableprinter"
"github.com/cli/cli/v2/internal/text"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/spf13/cobra"
)
type ListOptions struct {
IO *iostreams.IOStreams
Config func() (config.Config, error)
HttpClient func() (*http.Client, error)
Limit int
}
func NewCmdList(f *cmdutil.Factory, runF func(*ListOptions) error) *cobra.Command {
opts := ListOptions{
IO: f.IOStreams,
Config: f.Config,
HttpClient: f.HttpClient,
}
cmd := &cobra.Command{
Use: "list",
Args: cobra.MaximumNArgs(1),
Short: "List organizations for the authenticated user.",
Example: heredoc.Doc(`
# List the first 30 organizations
$ gh org list
# List more organizations
$ gh org list --limit 100
`),
RunE: func(cmd *cobra.Command, args []string) error {
if opts.Limit < 1 {
return cmdutil.FlagErrorf("invalid limit: %v", opts.Limit)
}
if runF != nil {
return runF(&opts)
}
return listRun(&opts)
},
}
cmd.Flags().IntVarP(&opts.Limit, "limit", "L", 30, "Maximum number of organizations to list")
return cmd
}
func listRun(opts *ListOptions) error {
httpClient, err := opts.HttpClient()
if err != nil {
return err
}
cfg, err := opts.Config()
if err != nil {
return err
}
host, _ := cfg.Authentication().DefaultHost()
listResult, err := listOrgs(httpClient, host, opts.Limit)
if err != nil {
return err
}
if err := opts.IO.StartPager(); err != nil {
fmt.Fprintf(opts.IO.ErrOut, "error starting pager: %v\n", err)
}
defer opts.IO.StopPager()
if opts.IO.IsStdoutTTY() {
header := listHeader(listResult.User, len(listResult.Organizations), listResult.TotalCount)
fmt.Fprintf(opts.IO.Out, "\n%s\n\n", header)
}
table := tableprinter.New(opts.IO)
for _, org := range listResult.Organizations {
table.AddField(org.Login)
table.EndRow()
}
err = table.Render()
if err != nil {
return err
}
return nil
}
func listHeader(user string, resultCount, totalCount int) string {
if totalCount == 0 {
return "There are no organizations associated with @" + user
}
return fmt.Sprintf("Showing %d of %s", resultCount, text.Pluralize(totalCount, "organization"))
}

237
pkg/cmd/org/list/list_test.go Normal file
View file

@ -0,0 +1,237 @@
package list
import (
"bytes"
"net/http"
"testing"
"github.com/MakeNowJust/heredoc"
"github.com/cli/cli/v2/internal/config"
"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
cli string
wants ListOptions
wantsErr string
}{
{
name: "no arguments",
cli: "",
wants: ListOptions{
Limit: 30,
},
},
{
name: "with limit",
cli: "-L 101",
wants: ListOptions{
Limit: 101,
},
},
{
name: "too many arguments",
cli: "123 456",
wantsErr: "accepts at most 1 arg(s), received 2",
},
{
name: "invalid limit",
cli: "-L 0",
wantsErr: "invalid limit: 0",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := &cmdutil.Factory{}
argv, err := shlex.Split(tt.cli)
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.wantsErr != "" {
assert.EqualError(t, err, tt.wantsErr)
return
}
assert.NoError(t, err)
assert.Equal(t, tt.wants.Limit, gotOpts.Limit)
})
}
}
func TestListRun(t *testing.T) {
tests := []struct {
name string
opts ListOptions
isTTY bool
wantOut string
}{
{
name: "no organizations found",
opts: ListOptions{HttpClient: func() (*http.Client, error) {
r := &httpmock.Registry{}
r.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
r.Register(
httpmock.GraphQL(`query OrganizationList\b`),
httpmock.StringResponse(`
{ "data": { "user": {
"organizations": { "nodes": [], "totalCount": 0 }
} } }`,
),
)
return &http.Client{Transport: r}, nil
}},
isTTY: true,
wantOut: heredoc.Doc(`
There are no organizations associated with @octocat
`),
},
{
name: "default behavior",
opts: ListOptions{HttpClient: func() (*http.Client, error) {
r := &httpmock.Registry{}
r.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
r.Register(
httpmock.GraphQL(`query OrganizationList\b`),
httpmock.StringResponse(`
{ "data": { "user": { "organizations": {
"totalCount": 2,
"nodes": [
{
"login": "github"
},
{
"login": "cli"
}
] } } } }`,
),
)
return &http.Client{Transport: r}, nil
}},
isTTY: true,
wantOut: heredoc.Doc(`
Showing 2 of 2 organizations
github
cli
`),
},
{
name: "with limit",
opts: ListOptions{Limit: 1, HttpClient: func() (*http.Client, error) {
r := &httpmock.Registry{}
r.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
r.Register(
httpmock.GraphQL(`query OrganizationList\b`),
httpmock.StringResponse(`
{ "data": { "user": { "organizations": {
"totalCount": 2,
"nodes": [
{
"login": "github"
},
{
"login": "cli"
}
] } } } }`,
),
)
return &http.Client{Transport: r}, nil
}},
isTTY: true,
wantOut: heredoc.Doc(`
Showing 1 of 2 organizations
github
`),
},
{
name: "nontty output",
opts: ListOptions{HttpClient: func() (*http.Client, error) {
r := &httpmock.Registry{}
r.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"login": "octocat"}}}`))
r.Register(
httpmock.GraphQL(`query OrganizationList\b`),
httpmock.StringResponse(`
{ "data": { "user": { "organizations": {
"totalCount": 2,
"nodes": [
{
"login": "github"
},
{
"login": "cli"
}
] } } } }`,
),
)
return &http.Client{Transport: r}, nil
}},
isTTY: false,
wantOut: heredoc.Doc(`
github
cli
`),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ios, _, stdout, _ := iostreams.Test()
ios.SetStdoutTTY(tt.isTTY)
ios.SetStdinTTY(tt.isTTY)
ios.SetStderrTTY(tt.isTTY)
tt.opts.IO = ios
tt.opts.Config = func() (config.Config, error) {
return config.NewBlankConfig(), nil
}
err := listRun(&tt.opts)
assert.NoError(t, err)
assert.Equal(t, tt.wantOut, stdout.String())
})
}
}

24
pkg/cmd/org/org.go Normal file
View file

@ -0,0 +1,24 @@
package org
import (
"github.com/MakeNowJust/heredoc"
orgListCmd "github.com/cli/cli/v2/pkg/cmd/org/list"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/spf13/cobra"
)
func NewCmdOrg(f *cmdutil.Factory) *cobra.Command {
cmd := &cobra.Command{
Use: "org <command>",
Short: "Manage organizations",
Long: "Work with Github organizations.",
Example: heredoc.Doc(`
$ gh org list
`),
GroupID: "core",
}
cmdutil.AddGroup(cmd, "General commands", orgListCmd.NewCmdList(f, nil))
return cmd
}

2
pkg/cmd/repo/delete/delete.go
View file

@ -10,7 +10,7 @@ import (
"github.com/cli/cli/v2/internal/ghrepo"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
ghAuth "github.com/cli/go-gh/pkg/auth"
ghAuth "github.com/cli/go-gh/v2/pkg/auth"
"github.com/spf13/cobra"
)

2
pkg/cmd/repo/list/http.go
View file

@ -209,7 +209,7 @@ func searchQuery(owner string, filter FilterOptions) string {
Is: []string{filter.Visibility},
Language: filter.Language,
Topic: filter.Topic,
User: owner,
User: []string{owner},
},
}

2
pkg/cmd/root/root.go
View file

@ -22,6 +22,7 @@ import (
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"
orgCmd "github.com/cli/cli/v2/pkg/cmd/org"
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"
@ -115,6 +116,7 @@ func NewCmdRoot(f *cmdutil.Factory, version, buildDate string) *cobra.Command {
cmd.AddCommand(browseCmd.NewCmdBrowse(&repoResolvingCmdFactory, nil))
cmd.AddCommand(prCmd.NewCmdPR(&repoResolvingCmdFactory))
cmd.AddCommand(orgCmd.NewCmdOrg(&repoResolvingCmdFactory))
cmd.AddCommand(issueCmd.NewCmdIssue(&repoResolvingCmdFactory))
cmd.AddCommand(releaseCmd.NewCmdRelease(&repoResolvingCmdFactory))
cmd.AddCommand(repoCmd.NewCmdRepo(&repoResolvingCmdFactory))

2
pkg/cmd/search/commits/commits.go
View file

@ -114,7 +114,7 @@ func NewCmdCommits(f *cmdutil.Factory, runF func(*CommitsOptions) error) *cobra.
cmd.Flags().StringVar(&opts.Query.Qualifiers.Parent, "parent", "", "Filter by parent hash")
cmd.Flags().StringSliceVarP(&opts.Query.Qualifiers.Repo, "repo", "R", nil, "Filter on repository")
cmd.Flags().StringVar(&opts.Query.Qualifiers.Tree, "tree", "", "Filter by tree hash")
cmd.Flags().StringVar(&opts.Query.Qualifiers.User, "owner", "", "Filter on repository owner")
cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.User, "owner", nil, "Filter on repository owner")
cmdutil.StringSliceEnumFlag(cmd, &opts.Query.Qualifiers.Is, "visibility", "", nil, []string{"public", "private", "internal"}, "Filter based on repository visibility")
return cmd

2
pkg/cmd/search/commits/commits_test.go
View file

@ -106,7 +106,7 @@ func TestNewCmdCommits(t *testing.T) {
Parent: "bbb",
Repo: []string{"owner/repo"},
Tree: "ccc",
User: "owner",
User: []string{"owner"},
Is: []string{"public"},
},
},

2
pkg/cmd/search/issues/issues.go
View file

@ -160,7 +160,7 @@ func NewCmdIssues(f *cmdutil.Factory, runF func(*shared.IssuesOptions) error) *c
cmdutil.StringEnumFlag(cmd, &opts.Query.Qualifiers.State, "state", "", "", []string{"open", "closed"}, "Filter based on state")
cmd.Flags().StringVar(&opts.Query.Qualifiers.Team, "team-mentions", "", "Filter based on team mentions")
cmd.Flags().StringVar(&opts.Query.Qualifiers.Updated, "updated", "", "Filter on last updated at `date`")
cmd.Flags().StringVar(&opts.Query.Qualifiers.User, "owner", "", "Filter on repository owner")
cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.User, "owner", nil, "Filter on repository owner")
return cmd
}

2
pkg/cmd/search/prs/prs.go
View file

@ -171,7 +171,7 @@ func NewCmdPrs(f *cmdutil.Factory, runF func(*shared.IssuesOptions) error) *cobr
cmdutil.StringEnumFlag(cmd, &opts.Query.Qualifiers.State, "state", "", "", []string{"open", "closed"}, "Filter based on state")
cmd.Flags().StringVar(&opts.Query.Qualifiers.Team, "team-mentions", "", "Filter based on team mentions")
cmd.Flags().StringVar(&opts.Query.Qualifiers.Updated, "updated", "", "Filter on last updated at `date`")
cmd.Flags().StringVar(&opts.Query.Qualifiers.User, "owner", "", "Filter on repository owner")
cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.User, "owner", nil, "Filter on repository owner")
// Pull request query qualifier flags
cmd.Flags().StringVarP(&opts.Query.Qualifiers.Base, "base", "B", "", "Filter on base branch name")

2
pkg/cmd/search/repos/repos.go
View file

@ -118,7 +118,7 @@ func NewCmdRepos(f *cmdutil.Factory, runF func(*ReposOptions) error) *cobra.Comm
cmd.Flags().StringVar(&opts.Query.Qualifiers.Stars, "stars", "", "Filter on `number` of stars")
cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.Topic, "topic", nil, "Filter on topic")
cmd.Flags().StringVar(&opts.Query.Qualifiers.Topics, "number-topics", "", "Filter on `number` of topics")
cmd.Flags().StringVar(&opts.Query.Qualifiers.User, "owner", "", "Filter on owner")
cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.User, "owner", nil, "Filter on owner")
return cmd
}

2
pkg/cmd/search/repos/repos_test.go
View file

@ -110,7 +110,7 @@ func TestNewCmdRepos(t *testing.T) {
Stars: "6",
Topic: []string{"topic"},
Topics: "7",
User: "owner",
User: []string{"owner"},
Is: []string{"public"},
},
},

13
pkg/cmd/ssh-key/add/add.go
View file

@ -7,6 +7,7 @@ import (
"os"
"github.com/cli/cli/v2/internal/config"
"github.com/cli/cli/v2/pkg/cmd/ssh-key/shared"
"github.com/cli/cli/v2/pkg/cmdutil"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/spf13/cobra"
@ -19,6 +20,7 @@ type AddOptions struct {
KeyFile string
Title string
Type string
}
func NewCmdAdd(f *cmdutil.Factory, runF func(*AddOptions) error) *cobra.Command {
@ -49,6 +51,8 @@ func NewCmdAdd(f *cmdutil.Factory, runF func(*AddOptions) error) *cobra.Command
},
}
typeEnums := []string{shared.AuthenticationKey, shared.SigningKey}
cmdutil.StringEnumFlag(cmd, &opts.Type, "type", "", shared.AuthenticationKey, typeEnums, "Type of the ssh key")
cmd.Flags().StringVarP(&opts.Title, "title", "t", "", "Title for the new key")
return cmd
}
@ -79,7 +83,14 @@ func runAdd(opts *AddOptions) error {
hostname, _ := cfg.Authentication().DefaultHost()
uploaded, err := SSHKeyUpload(httpClient, hostname, keyReader, opts.Title)
var uploaded bool
if opts.Type == shared.SigningKey {
uploaded, err = SSHSigningKeyUpload(httpClient, hostname, keyReader, opts.Title)
} else {
uploaded, err = SSHKeyUpload(httpClient, hostname, keyReader, opts.Title)
}
if err != nil {
return err
}

46
pkg/cmd/ssh-key/add/add_test.go
View file

@ -39,6 +39,25 @@ func Test_runAdd(t *testing.T) {
wantErrMsg: "",
opts: AddOptions{KeyFile: "-"},
},
{
name: "valid signing key format, not already in use",
stdin: "ssh-ed25519 asdf",
httpStubs: func(reg *httpmock.Registry) {
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse("[]"))
reg.Register(
httpmock.REST("POST", "user/ssh_signing_keys"),
httpmock.RESTPayload(200, ``, func(payload map[string]interface{}) {
assert.Contains(t, payload, "key")
assert.Empty(t, payload["title"])
}))
},
wantStdout: "",
wantStderr: "✓ Public key added to your account\n",
wantErrMsg: "",
opts: AddOptions{KeyFile: "-", Type: "signing"},
},
{
name: "valid key format, already in use",
stdin: "ssh-ed25519 asdf title",
@ -58,6 +77,25 @@ func Test_runAdd(t *testing.T) {
wantErrMsg: "",
opts: AddOptions{KeyFile: "-"},
},
{
name: "valid signing key format, already in use",
stdin: "ssh-ed25519 asdf title",
httpStubs: func(reg *httpmock.Registry) {
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse(`[
{
"id": 1,
"key": "ssh-ed25519 asdf",
"title": "anything"
}
]`))
},
wantStdout: "",
wantStderr: "✓ Public key already exists on your account\n",
wantErrMsg: "",
opts: AddOptions{KeyFile: "-", Type: "signing"},
},
{
name: "invalid key format",
stdin: "ssh-ed25519",
@ -66,6 +104,14 @@ func Test_runAdd(t *testing.T) {
wantErrMsg: "provided key is not in a valid format",
opts: AddOptions{KeyFile: "-"},
},
{
name: "invalid signing key format",
stdin: "ssh-ed25519",
wantStdout: "",
wantStderr: "",
wantErrMsg: "provided key is not in a valid format",
opts: AddOptions{KeyFile: "-", Type: "signing"},
},
}
for _, tt := range tests {

92
pkg/cmd/ssh-key/add/http.go
View file

@ -46,30 +46,82 @@ func SSHKeyUpload(httpClient *http.Client, hostname string, keyFile io.Reader, t
"key": fullUserKey,
}
payloadBytes, err := json.Marshal(payload)
if err != nil {
return false, err
}
err = keyUpload(httpClient, url, payload)
req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
if err != nil {
return false, err
}
resp, err := httpClient.Do(req)
if err != nil {
return false, err
}
defer resp.Body.Close()
if resp.StatusCode > 299 {
return false, api.HandleHTTPError(resp)
}
_, err = io.Copy(io.Discard, resp.Body)
if err != nil {
return false, err
}
return true, nil
}
// Uploads the provided SSH Signing key. Returns true if the key was uploaded, false if it was not.
func SSHSigningKeyUpload(httpClient *http.Client, hostname string, keyFile io.Reader, title string) (bool, error) {
url := ghinstance.RESTPrefix(hostname) + "user/ssh_signing_keys"
keyBytes, err := io.ReadAll(keyFile)
if err != nil {
return false, err
}
fullUserKey := string(keyBytes)
splitKey := strings.Fields(fullUserKey)
if len(splitKey) < 2 {
return false, errors.New("provided key is not in a valid format")
}
keyToCompare := splitKey[0] + " " + splitKey[1]
keys, err := shared.UserSigningKeys(httpClient, hostname, "")
if err != nil {
return false, err
}
for _, k := range keys {
if k.Key == keyToCompare {
return false, nil
}
}
payload := map[string]string{
"title": title,
"key": fullUserKey,
}
err = keyUpload(httpClient, url, payload)
if err != nil {
return false, err
}
return true, nil
}
func keyUpload(httpClient *http.Client, url string, payload map[string]string) error {
payloadBytes, err := json.Marshal(payload)
if err != nil {
return err
}
req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
if err != nil {
return err
}
resp, err := httpClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode > 299 {
return api.HandleHTTPError(resp)
}
_, err = io.Copy(io.Discard, resp.Body)
if err != nil {
return err
}
return nil
}

35
pkg/cmd/ssh-key/list/list.go
View file

@ -1,10 +1,14 @@
package list
import (
"errors"
"fmt"
"io"
"net/http"
"strconv"
"time"
"github.com/cli/cli/v2/api"
"github.com/cli/cli/v2/internal/config"
"github.com/cli/cli/v2/internal/text"
"github.com/cli/cli/v2/pkg/cmd/ssh-key/shared"
@ -55,12 +59,22 @@ func listRun(opts *ListOptions) error {
}
host, _ := cfg.Authentication().DefaultHost()
sshKeys, err := shared.UserKeys(apiClient, host, "")
if err != nil {
return err
sshAuthKeys, authKeyErr := shared.UserKeys(apiClient, host, "")
if authKeyErr != nil {
printError(opts.IO.ErrOut, authKeyErr)
}
sshSigningKeys, signKeyErr := shared.UserSigningKeys(apiClient, host, "")
if signKeyErr != nil {
printError(opts.IO.ErrOut, signKeyErr)
}
if authKeyErr != nil && signKeyErr != nil {
return cmdutil.SilentError
}
sshKeys := append(sshAuthKeys, sshSigningKeys...)
if len(sshKeys) == 0 {
return cmdutil.NewNoResultsError("no SSH keys present in the GitHub account")
}
@ -74,6 +88,7 @@ func listRun(opts *ListOptions) error {
t.AddField("TITLE", nil, nil)
t.AddField("ID", nil, nil)
t.AddField("KEY", nil, nil)
t.AddField("TYPE", nil, nil)
t.AddField("ADDED", nil, nil)
t.EndRow()
}
@ -86,12 +101,14 @@ func listRun(opts *ListOptions) error {
t.AddField(sshKey.Title, nil, nil)
t.AddField(id, nil, nil)
t.AddField(sshKey.Key, truncateMiddle, nil)
t.AddField(sshKey.Type, nil, nil)
t.AddField(text.FuzzyAgoAbbr(now, sshKey.CreatedAt), nil, cs.Gray)
} else {
t.AddField(sshKey.Title, nil, nil)
t.AddField(sshKey.Key, nil, nil)
t.AddField(createdAt, nil, nil)
t.AddField(id, nil, nil)
t.AddField(sshKey.Type, nil, nil)
}
t.EndRow()
@ -114,3 +131,13 @@ func truncateMiddle(maxWidth int, t string) string {
remainder := (maxWidth - len(ellipsis)) % 2
return t[0:halfWidth+remainder] + ellipsis + t[len(t)-halfWidth:]
}
func printError(w io.Writer, err error) {
fmt.Fprintln(w, "warning: ", err)
var httpErr api.HTTPError
if errors.As(err, &httpErr) {
if msg := httpErr.ScopesSuggestion(); msg != "" {
fmt.Fprintln(w, msg)
}
}
}

114
pkg/cmd/ssh-key/list/list_test.go
View file

@ -22,7 +22,7 @@ func TestListRun(t *testing.T) {
wantErr bool
}{
{
name: "list tty",
name: "list authentication and signing keys; in tty",
opts: ListOptions{
HTTPClient: func() (*http.Client, error) {
createdAt := time.Now().Add(time.Duration(-24) * time.Hour)
@ -44,19 +44,31 @@ func TestListRun(t *testing.T) {
}
]`, createdAt.Format(time.RFC3339))),
)
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse(fmt.Sprintf(`[
{
"id": 321,
"key": "ssh-rsa AAAABbBB123",
"title": "Mac Signing",
"created_at": "%[1]s"
}
]`, createdAt.Format(time.RFC3339))),
)
return &http.Client{Transport: reg}, nil
},
},
isTTY: true,
wantStdout: heredoc.Doc(`
TITLE ID KEY ADDED
Mac 1234 ssh-rsa AAAABbBB123 1d
hubot@Windows 5678 ssh-rsa EEEEEEEK247 1d
TITLE ID KEY TYPE ADDED
Mac 1234 ssh-rsa AAAABbBB123 authentication 1d
hubot@Windows 5678 ssh-rsa EEEEEEEK247 authentication 1d
Mac Signing 321 ssh-rsa AAAABbBB123 signing 1d
`),
wantStderr: "",
},
{
name: "list non-tty",
name: "list authentication and signing keys; in non-tty",
opts: ListOptions{
HTTPClient: func() (*http.Client, error) {
createdAt, _ := time.Parse(time.RFC3339, "2020-08-31T15:44:24+02:00")
@ -78,16 +90,96 @@ func TestListRun(t *testing.T) {
}
]`, createdAt.Format(time.RFC3339))),
)
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse(fmt.Sprintf(`[
{
"id": 321,
"key": "ssh-rsa AAAABbBB123",
"title": "Mac Signing",
"created_at": "%[1]s"
}
]`, createdAt.Format(time.RFC3339))),
)
return &http.Client{Transport: reg}, nil
},
},
isTTY: false,
wantStdout: heredoc.Doc(`
Mac ssh-rsa AAAABbBB123 2020-08-31T15:44:24+02:00 1234
hubot@Windows ssh-rsa EEEEEEEK247 2020-08-31T15:44:24+02:00 5678
Mac ssh-rsa AAAABbBB123 2020-08-31T15:44:24+02:00 1234 authentication
hubot@Windows ssh-rsa EEEEEEEK247 2020-08-31T15:44:24+02:00 5678 authentication
Mac Signing ssh-rsa AAAABbBB123 2020-08-31T15:44:24+02:00 321 signing
`),
wantStderr: "",
},
{
name: "only authentication ssh keys are available",
opts: ListOptions{
HTTPClient: func() (*http.Client, error) {
createdAt := time.Now().Add(time.Duration(-24) * time.Hour)
reg := &httpmock.Registry{}
reg.Register(
httpmock.REST("GET", "user/keys"),
httpmock.StringResponse(fmt.Sprintf(`[
{
"id": 1234,
"key": "ssh-rsa AAAABbBB123",
"title": "Mac",
"created_at": "%[1]s"
}
]`, createdAt.Format(time.RFC3339))),
)
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StatusStringResponse(404, "Not Found"),
)
return &http.Client{Transport: reg}, nil
},
},
wantStdout: heredoc.Doc(`
TITLE ID KEY TYPE ADDED
Mac 1234 ssh-rsa AAAABbBB123 authentication 1d
`),
wantStderr: heredoc.Doc(`
warning: HTTP 404 (https://api.github.com/user/ssh_signing_keys?per_page=100)
`),
wantErr: false,
isTTY: true,
},
{
name: "only signing ssh keys are available",
opts: ListOptions{
HTTPClient: func() (*http.Client, error) {
createdAt := time.Now().Add(time.Duration(-24) * time.Hour)
reg := &httpmock.Registry{}
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse(fmt.Sprintf(`[
{
"id": 1234,
"key": "ssh-rsa AAAABbBB123",
"title": "Mac",
"created_at": "%[1]s"
}
]`, createdAt.Format(time.RFC3339))),
)
reg.Register(
httpmock.REST("GET", "user/keys"),
httpmock.StatusStringResponse(404, "Not Found"),
)
return &http.Client{Transport: reg}, nil
},
},
wantStdout: heredoc.Doc(`
TITLE ID KEY TYPE ADDED
Mac 1234 ssh-rsa AAAABbBB123 signing 1d
`),
wantStderr: heredoc.Doc(`
warning: HTTP 404 (https://api.github.com/user/keys?per_page=100)
`),
wantErr: false,
isTTY: true,
},
{
name: "no keys tty",
opts: ListOptions{
@ -97,6 +189,10 @@ func TestListRun(t *testing.T) {
httpmock.REST("GET", "user/keys"),
httpmock.StringResponse(`[]`),
)
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse(`[]`),
)
return &http.Client{Transport: reg}, nil
},
},
@ -114,6 +210,10 @@ func TestListRun(t *testing.T) {
httpmock.REST("GET", "user/keys"),
httpmock.StringResponse(`[]`),
)
reg.Register(
httpmock.REST("GET", "user/ssh_signing_keys"),
httpmock.StringResponse(`[]`),
)
return &http.Client{Transport: reg}, nil
},
},

41
pkg/cmd/ssh-key/shared/user_keys.go
View file

@ -11,10 +11,16 @@ import (
"github.com/cli/cli/v2/internal/ghinstance"
)
const (
AuthenticationKey = "authentication"
SigningKey = "signing"
)
type sshKey struct {
ID int
Key string
Title string
Type string
CreatedAt time.Time `json:"created_at"`
}
@ -24,6 +30,41 @@ func UserKeys(httpClient *http.Client, host, userHandle string) ([]sshKey, error
resource = fmt.Sprintf("users/%s/keys", userHandle)
}
url := fmt.Sprintf("%s%s?per_page=%d", ghinstance.RESTPrefix(host), resource, 100)
keys, err := getUserKeys(httpClient, url)
if err != nil {
return nil, err
}
for i := 0; i < len(keys); i++ {
keys[i].Type = AuthenticationKey
}
return keys, nil
}
func UserSigningKeys(httpClient *http.Client, host, userHandle string) ([]sshKey, error) {
resource := "user/ssh_signing_keys"
if userHandle != "" {
resource = fmt.Sprintf("users/%s/ssh_signing_keys", userHandle)
}
url := fmt.Sprintf("%s%s?per_page=%d", ghinstance.RESTPrefix(host), resource, 100)
keys, err := getUserKeys(httpClient, url)
if err != nil {
return nil, err
}
for i := 0; i < len(keys); i++ {
keys[i].Type = SigningKey
}
return keys, nil
}
func getUserKeys(httpClient *http.Client, url string) ([]sshKey, error) {
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err

6
pkg/cmd/status/status.go
View file

@ -20,7 +20,7 @@ import (
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/cli/v2/pkg/set"
"github.com/cli/cli/v2/utils"
ghAPI "github.com/cli/go-gh/pkg/api"
ghAPI "github.com/cli/go-gh/v2/pkg/api"
"github.com/spf13/cobra"
"golang.org/x/sync/errgroup"
)
@ -429,7 +429,7 @@ func (s *StatusGetter) LoadSearchResults() error {
if err != nil {
var gqlErrResponse api.GraphQLError
if errors.As(err, &gqlErrResponse) {
gqlErrors := make([]ghAPI.GQLErrorItem, 0, len(gqlErrResponse.Errors))
gqlErrors := make([]ghAPI.GraphQLErrorItem, 0, len(gqlErrResponse.Errors))
// Exclude any FORBIDDEN errors and show status for what we can.
for _, gqlErr := range gqlErrResponse.Errors {
if gqlErr.Type == "FORBIDDEN" {
@ -442,7 +442,7 @@ func (s *StatusGetter) LoadSearchResults() error {
err = nil
} else {
err = api.GraphQLError{
GQLError: ghAPI.GQLError{
GraphQLError: &ghAPI.GraphQLError{
Errors: gqlErrors,
},
}

4
pkg/cmdutil/json_flags.go
View file

@ -13,8 +13,8 @@ import (
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/cli/v2/pkg/jsoncolor"
"github.com/cli/cli/v2/pkg/set"
"github.com/cli/go-gh/pkg/jq"
"github.com/cli/go-gh/pkg/template"
"github.com/cli/go-gh/v2/pkg/jq"
"github.com/cli/go-gh/v2/pkg/template"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
)

2
pkg/iostreams/iostreams.go
View file

@ -13,7 +13,7 @@ import (
"time"
"github.com/briandowns/spinner"
ghTerm "github.com/cli/go-gh/pkg/term"
ghTerm "github.com/cli/go-gh/v2/pkg/term"
"github.com/cli/safeexec"
"github.com/google/shlex"
"github.com/mattn/go-colorable"

2
pkg/markdown/markdown.go
View file

@ -2,7 +2,7 @@ package markdown
import (
"github.com/charmbracelet/glamour"
ghMarkdown "github.com/cli/go-gh/pkg/markdown"
ghMarkdown "github.com/cli/go-gh/v2/pkg/markdown"
)
func WithoutIndentation() glamour.TermRendererOption {

2
pkg/search/query.go
View file

@ -79,7 +79,7 @@ type Qualifiers struct {
Tree string
Type string
Updated string
User string
User []string
}
func (q Query) String() string {

13
pkg/search/query_test.go
View file

@ -36,11 +36,14 @@ func TestQueryString(t *testing.T) {
Stars: "6",
Topic: []string{"topic"},
Topics: "7",
User: "user",
User: []string{"user1", "user2"},
Is: []string{"public"},
},
},
out: "some keywords archived:true author-email:foo@example.com committer-date:2021-02-28 created:created followers:1 fork:true forks:2 good-first-issues:3 help-wanted-issues:4 in:description in:readme is:public language:language license:license pushed:updated size:5 stars:6 topic:topic topics:7 user:user",
out: "some keywords archived:true author-email:foo@example.com committer-date:2021-02-28 " +
"created:created followers:1 fork:true forks:2 good-first-issues:3 help-wanted-issues:4 " +
"in:description in:readme is:public language:language license:license pushed:updated size:5 " +
"stars:6 topic:topic topics:7 user:user1 user:user2",
},
{
name: "quotes keywords",
@ -100,7 +103,7 @@ func TestQualifiersMap(t *testing.T) {
Stars: "6",
Topic: []string{"topic"},
Topics: "7",
User: "user",
User: []string{"user1", "user2"},
},
out: map[string][]string{
"archived": {"true"},
@ -121,7 +124,7 @@ func TestQualifiersMap(t *testing.T) {
"stars": {"6"},
"topic": {"topic"},
"topics": {"7"},
"user": {"user"},
"user": {"user1", "user2"},
},
},
{
@ -130,7 +133,7 @@ func TestQualifiersMap(t *testing.T) {
Pushed: "updated",
Size: "5",
Stars: "6",
User: "user",
User: []string{"user"},
},
out: map[string][]string{
"pushed": {"updated"},

2
utils/table_printer.go
View file

@ -5,7 +5,7 @@ import (
"strings"
"github.com/cli/cli/v2/pkg/iostreams"
"github.com/cli/go-gh/pkg/tableprinter"
"github.com/cli/go-gh/v2/pkg/tableprinter"
)
type TablePrinter interface {