Split the library into packages

Author: mislav

api/access_token.go

@@ -0,0 +1,23 @@
+package api
+
+// AccessToken is an OAuth access token.
+type AccessToken struct {
+	// The token value, typically a 40-character random string.
+	Token string
+	// The token type, e.g. "bearer".
+	Type string
+	// Space-separated list of OAuth scopes that this token grants.
+	Scope string
+}
+
+func (f FormResponse) AccessToken() (*AccessToken, error) {
+	if accessToken := f.Get("access_token"); accessToken != "" {
+		return &AccessToken{
+			Token: accessToken,
+			Type:  f.Get("token_type"),
+			Scope: f.Get("scope"),
+		}, nil
+	}
+
+	return nil, f.Err()
+}

api/access_token_test.go

@@ -0,0 +1,63 @@
+package api
+
+import (
+	"net/url"
+	"reflect"
+	"testing"
+)
+
+func TestFormResponse_AccessToken(t *testing.T) {
+	tests := []struct {
+		name     string
+		response FormResponse
+		want     *AccessToken
+		wantErr  *Error
+	}{
+		{
+			name: "with token",
+			response: FormResponse{
+				values: url.Values{
+					"access_token": []string{"ATOKEN"},
+					"token_type":   []string{"bearer"},
+					"scope":        []string{"repo gist"},
+				},
+			},
+			want: &AccessToken{
+				Token: "ATOKEN",
+				Type:  "bearer",
+				Scope: "repo gist",
+			},
+			wantErr: nil,
+		},
+		{
+			name: "no token",
+			response: FormResponse{
+				StatusCode: 200,
+				values: url.Values{
+					"error": []string{"access_denied"},
+				},
+			},
+			want: nil,
+			wantErr: &Error{
+				Code:         "access_denied",
+				ResponseCode: 200,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.response.AccessToken()
+			if err != nil {
+				apiError := err.(*Error)
+				if !reflect.DeepEqual(apiError, tt.wantErr) {
+					t.Fatalf("error %v, want %v", apiError, tt.wantErr)
+				}
+			} else if tt.wantErr != nil {
+				t.Fatalf("want error %v, got nil", tt.wantErr)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("FormResponse.AccessToken() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

api/form.go

@@ -0,0 +1,99 @@
+package api
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+type httpClient interface {
+	PostForm(string, url.Values) (*http.Response, error)
+}
+
+// FormResponse is the parsed "www-form-urlencoded" response from the server.
+type FormResponse struct {
+	StatusCode int
+
+	requestURI string
+	values     url.Values
+}
+
+// Get the response value named k.
+func (f FormResponse) Get(k string) string {
+	return f.values.Get(k)
+}
+
+func (f FormResponse) Err() error {
+	return &Error{
+		RequestURI:   f.requestURI,
+		ResponseCode: f.StatusCode,
+		Code:         f.Get("error"),
+		message:      f.Get("error_description"),
+	}
+}
+
+// Error is the result of an unexpected HTTP response from the server.
+type Error struct {
+	Code         string
+	ResponseCode int
+	RequestURI   string
+
+	message string
+}
+
+func (e Error) Error() string {
+	if e.message != "" {
+		return fmt.Sprintf("%s (%s)", e.message, e.Code)
+	}
+	if e.Code != "" {
+		return e.Code
+	}
+	return fmt.Sprintf("HTTP %d", e.ResponseCode)
+}
+
+// PostForm makes an POST request by serializing input parameters as a form and parsing the response
+// of the same type.
+func PostForm(c httpClient, u string, params url.Values) (*FormResponse, error) {
+	resp, err := c.PostForm(u, params)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	r := &FormResponse{
+		StatusCode: resp.StatusCode,
+		requestURI: u,
+	}
+
+	if contentType(resp.Header.Get("Content-Type")) == formType {
+		var bb []byte
+		bb, err = ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return r, err
+		}
+
+		r.values, err = url.ParseQuery(string(bb))
+		if err != nil {
+			return r, err
+		}
+	} else {
+		_, err = io.Copy(ioutil.Discard, resp.Body)
+		if err != nil {
+			return r, err
+		}
+	}
+
+	return r, nil
+}
+
+const formType = "application/x-www-form-urlencoded"
+
+func contentType(t string) string {
+	if i := strings.IndexRune(t, ';'); i >= 0 {
+		return t[0:i]
+	}
+	return t
+}

api/form_test.go

@@ -0,0 +1,196 @@
+package api
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"reflect"
+	"testing"
+)
+
+func TestFormResponse_Get(t *testing.T) {
+	tests := []struct {
+		name     string
+		response FormResponse
+		key      string
+		want     string
+	}{
+		{
+			name:     "blank",
+			response: FormResponse{},
+			key:      "access_token",
+			want:     "",
+		},
+		{
+			name: "with value",
+			response: FormResponse{
+				values: url.Values{
+					"access_token": []string{"ATOKEN"},
+				},
+			},
+			key:  "access_token",
+			want: "ATOKEN",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.response.Get(tt.key); got != tt.want {
+				t.Errorf("FormResponse.Get() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestFormResponse_Err(t *testing.T) {
+	tests := []struct {
+		name     string
+		response FormResponse
+		wantErr  Error
+		errorMsg string
+	}{
+		{
+			name:     "blank",
+			response: FormResponse{},
+			wantErr:  Error{},
+			errorMsg: "HTTP 0",
+		},
+		{
+			name: "with values",
+			response: FormResponse{
+				StatusCode: 422,
+				requestURI: "http://example.com/path",
+				values: url.Values{
+					"error":             []string{"try_again"},
+					"error_description": []string{"maybe it works later"},
+				},
+			},
+			wantErr: Error{
+				Code:         "try_again",
+				ResponseCode: 422,
+				RequestURI:   "http://example.com/path",
+			},
+			errorMsg: "maybe it works later (try_again)",
+		},
+		{
+			name: "no values",
+			response: FormResponse{
+				StatusCode: 422,
+				requestURI: "http://example.com/path",
+			},
+			wantErr: Error{
+				Code:         "",
+				ResponseCode: 422,
+				RequestURI:   "http://example.com/path",
+			},
+			errorMsg: "HTTP 422",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.response.Err()
+			if err == nil {
+				t.Fatalf("FormResponse.Err() = %v, want %v", nil, tt.wantErr)
+			}
+			apiError := err.(*Error)
+			if apiError.Code != tt.wantErr.Code {
+				t.Errorf("Error.Code = %v, want %v", apiError.Code, tt.wantErr.Code)
+			}
+			if apiError.ResponseCode != tt.wantErr.ResponseCode {
+				t.Errorf("Error.ResponseCode = %v, want %v", apiError.ResponseCode, tt.wantErr.ResponseCode)
+			}
+			if apiError.RequestURI != tt.wantErr.RequestURI {
+				t.Errorf("Error.RequestURI = %v, want %v", apiError.RequestURI, tt.wantErr.RequestURI)
+			}
+			if apiError.Error() != tt.errorMsg {
+				t.Errorf("Error.Error() = %q, want %q", apiError.Error(), tt.errorMsg)
+			}
+		})
+	}
+}
+
+type apiClient struct {
+	status      int
+	body        string
+	contentType string
+
+	postCount int
+}
+
+func (c *apiClient) PostForm(u string, params url.Values) (*http.Response, error) {
+	c.postCount++
+	return &http.Response{
+		Body: ioutil.NopCloser(bytes.NewBufferString(c.body)),
+		Header: http.Header{
+			"Content-Type": {c.contentType},
+		},
+		StatusCode: c.status,
+	}, nil
+}
+
+func TestPostForm(t *testing.T) {
+	type args struct {
+		url    string
+		params url.Values
+	}
+	tests := []struct {
+		name    string
+		args    args
+		http    apiClient
+		want    *FormResponse
+		wantErr bool
+	}{
+		{
+			name: "success",
+			args: args{
+				url: "https://github.com/oauth",
+			},
+			http: apiClient{
+				body:        "access_token=123abc&scopes=repo%20gist",
+				status:      200,
+				contentType: "application/x-www-form-urlencoded; charset=utf-8",
+			},
+			want: &FormResponse{
+				StatusCode: 200,
+				requestURI: "https://github.com/oauth",
+				values: url.Values{
+					"access_token": {"123abc"},
+					"scopes":       {"repo gist"},
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "HTML response",
+			args: args{
+				url: "https://github.com/oauth",
+			},
+			http: apiClient{
+				body:        "<h1>Something went wrong</h1>",
+				status:      502,
+				contentType: "text/html",
+			},
+			want: &FormResponse{
+				StatusCode: 502,
+				requestURI: "https://github.com/oauth",
+				values:     url.Values(nil),
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := PostForm(&tt.http, tt.args.url, tt.args.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("PostForm() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.http.postCount != 1 {
+				t.Errorf("expected PostForm to happen 1 time; happened %d times", tt.http.postCount)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("PostForm() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}