Rewrite xerrors with Go errors (int128#32)

Author: int128

e2e_test/authserver/handler.go

@@ -4,11 +4,11 @@
 package authserver
 
 import (
+	"errors"
+	"fmt"
 	"net/http"
 	"net/url"
 	"testing"
-
-	"golang.org/x/xerrors"
 )
 
 // AuthorizationRequest represents an authorization request described as:
@@ -55,13 +55,13 @@ func (h *Handler) serveHTTP(w http.ResponseWriter, r *http.Request) error {
 		q := r.URL.Query()
 		scope, state, redirectURI := q.Get("scope"), q.Get("state"), q.Get("redirect_uri")
 		if scope == "" {
-			return xerrors.New("scope is missing")
+			return errors.New("scope is missing")
 		}
 		if state == "" {
-			return xerrors.New("state is missing")
+			return errors.New("state is missing")
 		}
 		if redirectURI == "" {
-			return xerrors.New("redirect_uri is missing")
+			return errors.New("redirect_uri is missing")
 		}
 		to := h.NewAuthorizationResponse(AuthorizationRequest{
 			Scope:       scope,
@@ -73,14 +73,14 @@ func (h *Handler) serveHTTP(w http.ResponseWriter, r *http.Request) error {
 
 	case r.Method == "POST" && r.URL.Path == "/token":
 		if err := r.ParseForm(); err != nil {
-			return xerrors.Errorf("error while parsing form: %w", err)
+			return fmt.Errorf("error while parsing form: %w", err)
 		}
 		code, redirectURI := r.Form.Get("code"), r.Form.Get("redirect_uri")
 		if code == "" {
-			return xerrors.New("code is missing")
+			return errors.New("code is missing")
 		}
 		if redirectURI == "" {
-			return xerrors.New("redirect_uri is missing")
+			return errors.New("redirect_uri is missing")
 		}
 		status, b := h.NewTokenResponse(TokenRequest{
 			Code: code,
@@ -89,7 +89,7 @@ func (h *Handler) serveHTTP(w http.ResponseWriter, r *http.Request) error {
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(status)
 		if _, err := w.Write([]byte(b)); err != nil {
-			return xerrors.Errorf("error while writing response body: %w", err)
+			return fmt.Errorf("error while writing response body: %w", err)
 		}
 
 	default:

e2e_test/oauth2cli_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/tls"
 	"crypto/x509"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -16,7 +17,6 @@ import (
 	"github.com/int128/oauth2cli/e2e_test/authserver"
 	"golang.org/x/oauth2"
 	"golang.org/x/sync/errgroup"
-	"golang.org/x/xerrors"
 )
 
 func TestGetToken(t *testing.T) {
@@ -181,7 +181,7 @@ func successfulTest(t *testing.T, cfg oauth2cli.Config, h *authserver.Handler) {
 		case to := <-openBrowserCh:
 			status, body, err := openBrowserRequest(to)
 			if err != nil {
-				return xerrors.Errorf("could not open browser request: %w", err)
+				return fmt.Errorf("could not open browser request: %w", err)
 			}
 			t.Logf("got response body: %s", body)
 			if status != 200 {
@@ -192,14 +192,14 @@ func successfulTest(t *testing.T, cfg oauth2cli.Config, h *authserver.Handler) {
 			}
 			return nil
 		case <-ctx.Done():
-			return xerrors.Errorf("context done while waiting for opening browser: %w", ctx.Err())
+			return fmt.Errorf("context done while waiting for opening browser: %w", ctx.Err())
 		}
 	})
 	eg.Go(func() error {
 		// Start a local server and get a token.
 		token, err := oauth2cli.GetToken(ctx, cfg)
 		if err != nil {
-			return xerrors.Errorf("could not get a token: %w", err)
+			return fmt.Errorf("could not get a token: %w", err)
 		}
 		if "ACCESS_TOKEN" != token.AccessToken {
 			t.Errorf("AccessToken wants %s but %s", "ACCESS_TOKEN", token.AccessToken)
@@ -243,22 +243,22 @@ func errorAuthorizationResponseTest(t *testing.T, cfg oauth2cli.Config) {
 		case to := <-openBrowserCh:
 			status, body, err := openBrowserRequest(to)
 			if err != nil {
-				return xerrors.Errorf("could not open browser request: %w", err)
+				return fmt.Errorf("could not open browser request: %w", err)
 			}
 			t.Logf("got response body: %s", body)
 			if status != 500 {
 				t.Errorf("status wants 500 but %d", status)
 			}
 			return nil
 		case <-ctx.Done():
-			return xerrors.Errorf("context done while waiting for opening browser: %w", ctx.Err())
+			return fmt.Errorf("context done while waiting for opening browser: %w", ctx.Err())
 		}
 	})
 	eg.Go(func() error {
 		// Start a local server and get a token.
 		_, err := oauth2cli.GetToken(ctx, cfg)
 		if err == nil {
-			return xerrors.New("GetToken wants error but was nil")
+			return errors.New("GetToken wants error but was nil")
 		}
 		t.Logf("expected error: %s", err)
 		return nil
@@ -297,7 +297,7 @@ func errorTokenResponseTest(t *testing.T, cfg oauth2cli.Config) {
 		case to := <-openBrowserCh:
 			status, body, err := openBrowserRequest(to)
 			if err != nil {
-				return xerrors.Errorf("could not open browser request: %w", err)
+				return fmt.Errorf("could not open browser request: %w", err)
 			}
 			t.Logf("got response body: %s", body)
 			if status != 200 {
@@ -308,14 +308,14 @@ func errorTokenResponseTest(t *testing.T, cfg oauth2cli.Config) {
 			}
 			return nil
 		case <-ctx.Done():
-			return xerrors.Errorf("context done while waiting for opening browser: %w", ctx.Err())
+			return fmt.Errorf("context done while waiting for opening browser: %w", ctx.Err())
 		}
 	})
 	eg.Go(func() error {
 		// Start a local server and get a token.
 		_, err := oauth2cli.GetToken(ctx, cfg)
 		if err == nil {
-			return xerrors.New("GetToken wants error but nil")
+			return errors.New("GetToken wants error but nil")
 		}
 		t.Logf("expected error: %s", err)
 		return nil
@@ -338,7 +338,7 @@ func openBrowserRequest(url string) (int, string, error) {
 	certPool := x509.NewCertPool()
 	data, err := ioutil.ReadFile("testdata/ca.pem")
 	if err != nil {
-		return 0, "", xerrors.Errorf("could not read certificate authority: %w", err)
+		return 0, "", fmt.Errorf("could not read certificate authority: %w", err)
 	}
 	if !certPool.AppendCertsFromPEM(data) {
 		return 0, "", fmt.Errorf("could not append certificate data")
@@ -348,12 +348,12 @@ func openBrowserRequest(url string) (int, string, error) {
 	client := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{RootCAs: certPool}}}
 	resp, err := client.Get(url)
 	if err != nil {
-		return 0, "", xerrors.Errorf("could not send a request: %w", err)
+		return 0, "", fmt.Errorf("could not send a request: %w", err)
 	}
 	defer resp.Body.Close()
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return resp.StatusCode, "", xerrors.Errorf("could not read response body: %w", err)
+		return resp.StatusCode, "", fmt.Errorf("could not read response body: %w", err)
 	}
 	return resp.StatusCode, string(b), nil
 }

example/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"flag"
+	"fmt"
 	"log"
 	"os"
 	"strings"
@@ -13,7 +14,6 @@ import (
 	"golang.org/x/oauth2"
 	"golang.org/x/oauth2/google"
 	"golang.org/x/sync/errgroup"
-	"golang.org/x/xerrors"
 )
 
 func init() {
@@ -85,14 +85,14 @@ Then set the following options:`)
 				log.Printf("could not open the browser: %s", err)
 			}
 			return nil
-		case err := <-ctx.Done():
-			return xerrors.Errorf("context done while waiting for authorization: %w", err)
+		case <-ctx.Done():
+			return fmt.Errorf("context done while waiting for authorization: %w", ctx.Err())
 		}
 	})
 	eg.Go(func() error {
 		token, err := oauth2cli.GetToken(ctx, cfg)
 		if err != nil {
-			return xerrors.Errorf("could not get a token: %w", err)
+			return fmt.Errorf("could not get a token: %w", err)
 		}
 		log.Printf("You got a valid token until %s", token.Expiry)
 		return nil

go.mod

@@ -6,7 +6,6 @@ require (
 	github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4
 	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
 	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e
-	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
 )
 
 go 1.13

go.sum

@@ -4,8 +4,6 @@ github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/int128/listener v1.0.0 h1:a9H3m4jbXgXpxJUK3fxWrh37Iic/UU/kYOGE0WtjbbI=
-github.com/int128/listener v1.0.0/go.mod h1:sho0rrH7mNRRZH4hYOYx+xwRDGmtRndaUiu2z9iumes=
 github.com/int128/listener v1.1.0 h1:2Jb41DWLpkQ3I9bIdBzO8H/tNwMvyl/OBZWtCV5Pjuw=
 github.com/int128/listener v1.1.0/go.mod h1:68WkmTN8PQtLzc9DucIaagAKeGVyMnyyKIkW4Xn47UA=
 github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4 h1:49lOXmGaUpV9Fz3gd7TFZY106KVlPVa5jcYD1gaQf98=
@@ -20,8 +18,6 @@ golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=

oauth2cli.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/int128/oauth2cli/oauth2params"
 	"golang.org/x/oauth2"
-	"golang.org/x/xerrors"
 )
 
 var noopMiddleware = func(h http.Handler) http.Handler { return h }
@@ -96,7 +95,7 @@ func GetToken(ctx context.Context, config Config) (*oauth2.Token, error) {
 	if config.State == "" {
 		s, err := oauth2params.NewState()
 		if err != nil {
-			return nil, xerrors.Errorf("could not generate a state parameter: %w", err)
+			return nil, fmt.Errorf("could not generate a state parameter: %w", err)
 		}
 		config.State = s
 	}
@@ -109,11 +108,11 @@ func GetToken(ctx context.Context, config Config) (*oauth2.Token, error) {
 	config.populateDeprecatedFields()
 	code, err := receiveCodeViaLocalServer(ctx, &config)
 	if err != nil {
-		return nil, xerrors.Errorf("authorization error: %w", err)
+		return nil, fmt.Errorf("authorization error: %w", err)
 	}
 	token, err := config.OAuth2Config.Exchange(ctx, code, config.TokenRequestOptions...)
 	if err != nil {
-		return nil, xerrors.Errorf("could not exchange the code and token: %w", err)
+		return nil, fmt.Errorf("could not exchange the code and token: %w", err)
 	}
 	return token, nil
 }

oauth2params/params.go

@@ -6,17 +6,17 @@ import (
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/binary"
+	"fmt"
 
 	"golang.org/x/oauth2"
-	"golang.org/x/xerrors"
 )
 
 // NewState returns a state parameter.
 // This generates 256 bits of random bytes.
 func NewState() (string, error) {
 	b, err := random(32)
 	if err != nil {
-		return "", xerrors.Errorf("could not generate a random: %w", err)
+		return "", fmt.Errorf("could not generate a random: %w", err)
 	}
 	return base64URLEncode(b), nil
 }
@@ -49,7 +49,7 @@ func (pkce *PKCE) TokenRequestOptions() []oauth2.AuthCodeOption {
 func NewPKCE() (*PKCE, error) {
 	b, err := random(32)
 	if err != nil {
-		return nil, xerrors.Errorf("could not generate a random: %w", err)
+		return nil, fmt.Errorf("could not generate a random: %w", err)
 	}
 	s := computeS256(b)
 	return &s, nil
@@ -69,7 +69,7 @@ func computeS256(b []byte) PKCE {
 func random(bits int) ([]byte, error) {
 	b := make([]byte, bits)
 	if err := binary.Read(rand.Reader, binary.LittleEndian, b); err != nil {
-		return nil, xerrors.Errorf("read error: %w", err)
+		return nil, fmt.Errorf("read error: %w", err)
 	}
 	return b, nil
 }