Add api tests

mislav · mislav · commit f58e0bf710a2 · 2020-05-20T15:21:32.000+02:00
diff --git a/pkg/cmd/api/api.go b/pkg/cmd/api/api.go
@@ -10,10 +10,14 @@ import (
 	"strings"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
 	"github.com/spf13/cobra"
 )
 
 type ApiOptions struct {
+	IO *iostreams.IOStreams
+
 	RequestMethod       string
 	RequestMethodPassed bool
 	RequestPath         string
@@ -54,9 +58,12 @@ on the format of the value:
 			opts.RequestPath = args[0]
 			opts.RequestMethodPassed = c.Flags().Changed("method")
 
+			// TODO: pass in via caller
+			opts.IO = iostreams.System()
+
 			opts.HttpClient = func() (*http.Client, error) {
 				ctx := context.New()
-				token, err := ctx.AuthLogin()
+				token, err := ctx.AuthToken()
 				if err != nil {
 					return nil, err
 				}
@@ -108,12 +115,16 @@ func apiRun(opts *ApiOptions) error {
 	}
 	defer resp.Body.Close()
 
-	// TODO: make stdout configurable for tests
-	_, err = io.Copy(os.Stdout, resp.Body)
+	_, err = io.Copy(opts.IO.Out, resp.Body)
 	if err != nil {
 		return err
 	}
 
+	// TODO: detect GraphQL errors
+	if resp.StatusCode > 299 {
+		return cmdutil.SilentError
+	}
+
 	return nil
 }
 
@@ -131,7 +142,7 @@ func parseFields(opts *ApiOptions) (map[string]interface{}, error) {
 		if err != nil {
 			return params, err
 		}
-		value, err := magicFieldValue(strValue)
+		value, err := magicFieldValue(strValue, opts.IO.In)
 		if err != nil {
 			return params, fmt.Errorf("error parsing %q value: %w", key, err)
 		}
@@ -148,12 +159,12 @@ func parseField(f string) (string, string, error) {
 	return f[0:idx], f[idx+1:], nil
 }
 
-func magicFieldValue(v string) (interface{}, error) {
+func magicFieldValue(v string, stdin io.ReadCloser) (interface{}, error) {
 	if strings.HasPrefix(v, "@") {
-		return readUserFile(v[1:])
+		return readUserFile(v[1:], stdin)
 	}
 
-	if n, err := strconv.Atoi(v); err != nil {
+	if n, err := strconv.Atoi(v); err == nil {
 		return n, nil
 	}
 
@@ -169,18 +180,17 @@ func magicFieldValue(v string) (interface{}, error) {
 	}
 }
 
-func readUserFile(fn string) ([]byte, error) {
+func readUserFile(fn string, stdin io.ReadCloser) ([]byte, error) {
 	var r io.ReadCloser
 	if fn == "-" {
-		// TODO: make stdin configurable for tests
-		r = os.Stdin
+		r = stdin
 	} else {
 		var err error
 		r, err = os.Open(fn)
 		if err != nil {
 			return nil, err
 		}
-		defer r.Close()
 	}
+	defer r.Close()
 	return ioutil.ReadAll(r)
 }
diff --git a/pkg/cmd/api/api_test.go b/pkg/cmd/api/api_test.go
@@ -0,0 +1,115 @@
+package api
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"reflect"
+	"testing"
+
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
+)
+
+func Test_apiRun(t *testing.T) {
+	tests := []struct {
+		name         string
+		httpResponse *http.Response
+		err          error
+		stdout       string
+		stderr       string
+	}{
+		{
+			name: "success",
+			httpResponse: &http.Response{
+				StatusCode: 200,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`bam!`)),
+			},
+			err:    nil,
+			stdout: `bam!`,
+			stderr: ``,
+		},
+		{
+			name: "failure",
+			httpResponse: &http.Response{
+				StatusCode: 502,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`gateway timeout`)),
+			},
+			err:    cmdutil.SilentError,
+			stdout: `gateway timeout`,
+			stderr: ``,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			io, _, stdout, stderr := iostreams.Test()
+
+			opts := ApiOptions{
+				IO: io,
+				HttpClient: func() (*http.Client, error) {
+					var tr roundTripper = func(req *http.Request) (*http.Response, error) {
+						resp := tt.httpResponse
+						resp.Request = req
+						return resp, nil
+					}
+					return &http.Client{Transport: tr}, nil
+				},
+
+				RawFields:   []string{},
+				MagicFields: []string{},
+			}
+
+			err := apiRun(&opts)
+			if err != tt.err {
+				t.Errorf("expected error %v, got %v", tt.err, err)
+			}
+
+			if stdout.String() != tt.stdout {
+				t.Errorf("expected output %q, got %q", tt.stdout, stdout.String())
+			}
+			if stderr.String() != tt.stderr {
+				t.Errorf("expected error output %q, got %q", tt.stderr, stderr.String())
+			}
+		})
+	}
+}
+
+func Test_parseFields(t *testing.T) {
+	io, stdin, _, _ := iostreams.Test()
+	fmt.Fprint(stdin, "pasted contents")
+
+	opts := ApiOptions{
+		IO: io,
+		RawFields: []string{
+			"robot=Hubot",
+			"destroyer=false",
+			"helper=true",
+			"location=@work",
+		},
+		MagicFields: []string{
+			"input=@-",
+			"enabled=true",
+			"victories=123",
+		},
+	}
+
+	params, err := parseFields(&opts)
+	if err != nil {
+		t.Fatalf("parseFields error: %v", err)
+	}
+
+	expect := map[string]interface{}{
+		"robot":     "Hubot",
+		"destroyer": "false",
+		"helper":    "true",
+		"location":  "@work",
+		"input":     []byte("pasted contents"),
+		"enabled":   true,
+		"victories": 123,
+	}
+	if !reflect.DeepEqual(params, expect) {
+		t.Errorf("expected %v, got %v", expect, params)
+	}
+}
diff --git a/pkg/cmd/api/http.go b/pkg/cmd/api/http.go
@@ -34,6 +34,8 @@ func httpRequest(client *http.Client, method string, p string, params interface{
 		}
 	case io.Reader:
 		body = pp
+	case nil:
+		body = nil
 	default:
 		return nil, fmt.Errorf("unrecognized parameters type: %v", params)
 	}
diff --git a/pkg/cmd/api/http_test.go b/pkg/cmd/api/http_test.go

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,8 @@ func httpRequest(client *http.Client, method string, p string, params interface{`
`34`	`34`	`}`
`35`	`35`	`case io.Reader:`
`36`	`36`	`body = pp`
	`37`	`+ case nil:`
	`38`	`+ body = nil`
`37`	`39`	`default:`
`38`	`40`	`return nil, fmt.Errorf("unrecognized parameters type: %v", params)`
`39`	`41`	`}`