Add CodeErr.Code method. Modernize a bit of the code. Update doc comments.

Author: bobg

err.go

@@ -7,11 +7,11 @@ import (
 	"net/http"
 )
 
-// Errf is a convenience wrapper for http.Error.
+// Errf is a convenience wrapper for [http.Error].
 // It calls http.Error(w, fmt.Sprintf(format, args...), code).
-// It also logs that message with log.Print.
-// If code is 0, it defaults to http.StatusInternalServerError.
-// If format is "", Errf uses http.StatusText instead.
+// It also logs that message with [log.Print].
+// If code is 0, it defaults to [http.StatusInternalServerError].
+// If format is "", Errf uses [http.StatusText] instead.
 func Errf(w http.ResponseWriter, code int, format string, args ...interface{}) {
 	if code == 0 {
 		code = http.StatusInternalServerError
@@ -28,14 +28,14 @@ func Errf(w http.ResponseWriter, code int, format string, args ...interface{}) {
 	http.Error(w, msg, code)
 }
 
-// Err wraps an error-returning function as an http.Handler.
-// If the returned error is a Responder (such as a CodeErr),
+// Err wraps an error-returning function as an [http.Handler].
+// If the returned error is a [Responder] (such as a [CodeErr]),
 // its Respond method is used to respond to the request.
 // Otherwise,
 // if a status code has not already been set,
-// an error return will set it to http.StatusInternalServerError,
-// and the absence of an error will set it to http.StatusOK,
-// or http.StatusNoContent if nothing has been written to the ResponseWriter.
+// an error return will set it to [http.StatusInternalServerError],
+// and the absence of an error will set it to [http.StatusOK],
+// or [http.StatusNoContent] if nothing has been written to the ResponseWriter.
 func Err(f func(http.ResponseWriter, *http.Request) error) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		ww := ResponseWrapper{W: w}
@@ -53,7 +53,7 @@ func Err(f func(http.ResponseWriter, *http.Request) error) http.Handler {
 	})
 }
 
-// CodeErr is an error that can be returned from the function wrapped by Err
+// CodeErr is an error that can be returned from the function wrapped by [Err]
 // to control the HTTP status code returned from the pending request.
 type CodeErr struct {
 	// C is an HTTP status code.
@@ -75,12 +75,12 @@ func (c CodeErr) Error() string {
 	return s
 }
 
-// Unwrap implements the interface for errors.Unwrap.
+// Unwrap implements the interface for [errors.Unwrap].
 func (c CodeErr) Unwrap() error {
 	return c.Err
 }
 
-// As implements the interface for errors.As.
+// As implements the interface for [errors.As].
 func (c CodeErr) As(target interface{}) bool {
 	if ptr, ok := target.(*CodeErr); ok {
 		*ptr = c
@@ -89,14 +89,19 @@ func (c CodeErr) As(target interface{}) bool {
 	return false
 }
 
-// Respond implements Responder.
+// Respond implements [Responder].
 func (c CodeErr) Respond(w http.ResponseWriter) {
 	http.Error(w, c.Error(), c.C)
 }
 
+// Code returns the HTTP status code.
+func (c CodeErr) Code() int {
+	return c.C
+}
+
 // Responder is an interface for objects that know how to respond to an HTTP request.
 // It is useful in the case of errors that want to set custom error strings and/or status codes
-// (e.g. via http.Error).
+// (e.g. via [http.Error]).
 type Responder interface {
 	Respond(http.ResponseWriter)
 }

err_test.go

@@ -2,7 +2,7 @@ package mid
 
 import (
 	"errors"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -74,7 +74,7 @@ func TestErr(t *testing.T) {
 				t.Errorf("got code %d, want %d", resp.StatusCode, c.wantCode)
 			}
 			if c.wantBody != "" {
-				body, err := ioutil.ReadAll(resp.Body)
+				body, err := io.ReadAll(resp.Body)
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -85,3 +85,10 @@ func TestErr(t *testing.T) {
 		})
 	}
 }
+
+func TestCode(t *testing.T) {
+	e := CodeErr{C: http.StatusTeapot}
+	if got := e.Code(); got != http.StatusTeapot {
+		t.Errorf("got code %d, want %d", got, http.StatusTeapot)
+	}
+}

go.mod

@@ -1,10 +1,10 @@
 module github.com/bobg/mid
 
-go 1.14
+go 1.21
 
 require (
+	github.com/bobg/errors v1.1.0
 	github.com/google/go-cmp v0.5.1
-	github.com/pkg/errors v0.9.1
 )
 
 retract v1.5.0

go.sum

@@ -1,6 +1,6 @@
+github.com/bobg/errors v1.1.0 h1:gsVanPzJMpZQpwY+27/GQYElZez5CuMYwiIpk2A3RGw=
+github.com/bobg/errors v1.1.0/go.mod h1:Q4775qBZpnte7EGFJqmvnlB1U4pkI1XmU3qxqdp7Zcc=
 github.com/google/go-cmp v0.5.1 h1:JFrFEBb2xKufg6XkJsJr+WbKb4FQlURi5RUcBveYu9k=
 github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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=

json.go

@@ -9,7 +9,7 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/pkg/errors"
+	"github.com/bobg/errors"
 )
 
 var (
@@ -22,7 +22,7 @@ type (
 	respKey struct{}
 )
 
-// JSON produces an http.Handler by JSON encoding and decoding of a given function's input and output.
+// JSON produces an [http.Handler] by JSON encoding and decoding of a given function's input and output.
 //
 // The signature of the function is:
 //
@@ -40,17 +40,17 @@ type (
 // When the function is called:
 //
 //   - If a context argument is present,
-//     it is supplied from the Context() method of the pending *http.Request.
+//     it is supplied from the Context() method of the pending [*http.Request].
 //     That context is further adorned with the pending *http.Request
-//     and the pending http.ResponseWriter,
-//     which can be retrieved with the Request and ResponseWriter functions.
+//     and the pending [http.ResponseWriter],
+//     which can be retrieved with the [Request] and [ResponseWriter] functions.
 //
 //   - If an inType argument is present,
 //     the request is checked to ensure that the method is POST
 //     and the Content-Type is application/json;
 //     then the request body is unmarshaled into the inType argument.
 //     Note that the JSON decoder uses the UseNumber setting;
-//     see https://golang.org/pkg/encoding/json/#Decoder.UseNumber.
+//     see [json.Decoder.UseNumber].
 //
 //   - If an outType result is present,
 //     it is JSON marshaled and written to the pending ResponseWriter
@@ -59,7 +59,7 @@ type (
 //     the default HTTP status is 204 (no content).
 //
 //   - If an error result is present,
-//     it is handled as in Err.
+//     it is handled as in [Err].
 //
 // Some of the code in this function is (liberally) adapted from github.com/chain/chain.
 func JSON(f interface{}) http.Handler {

limit.go

@@ -13,15 +13,15 @@ type Limiter interface {
 	Wait(context.Context) error
 }
 
-// LimitedTransport is an http.RoundTripper that limits the rate of requests it makes using a [Limiter].
+// LimitedTransport is an [http.RoundTripper] that limits the rate of requests it makes using a [Limiter].
 // After waiting for the limiter in L, it delegates to the http.RoundTripper in T.
 // If T is nil, it uses [http.DefaultTransport].
 type LimitedTransport struct {
 	L Limiter
 	T http.RoundTripper
 }
 
-// RoundTrip implements the http.RoundTripper interface.
+// RoundTrip implements the [http.RoundTripper] interface.
 func (lt LimitedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	if err := lt.L.Wait(req.Context()); err != nil {
 		return nil, err

limit_test.go

@@ -0,0 +1,67 @@
+package mid
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"testing"
+)
+
+func TestLimiter(t *testing.T) {
+	cases := []struct {
+		waitErr, rtErr error
+	}{{
+		waitErr: nil,
+		rtErr:   nil,
+	}, {
+		waitErr: errors.New("wait error"),
+	}, {
+		rtErr: errors.New("round trip error"),
+	}}
+
+	for i, tc := range cases {
+		t.Run(fmt.Sprintf("case_%02d", i+1), func(t *testing.T) {
+			var (
+				lim    = mockLimiter{waitErr: tc.waitErr}
+				transp = mockTransport{rtErr: tc.rtErr}
+				lt     = LimitedTransport{L: lim, T: transp}
+			)
+
+			_, err := lt.RoundTrip(&http.Request{})
+
+			switch {
+			case tc.waitErr != nil:
+				if !errors.Is(err, tc.waitErr) {
+					t.Errorf("got %v, want %v", err, tc.waitErr)
+				}
+
+			case tc.rtErr != nil:
+				if !errors.Is(err, tc.rtErr) {
+					t.Errorf("got %v, want %v", err, tc.rtErr)
+				}
+
+			default:
+				if err != nil {
+					t.Errorf("got %v, want nil", err)
+				}
+			}
+		})
+	}
+}
+
+type mockLimiter struct {
+	waitErr error
+}
+
+func (ml mockLimiter) Wait(context.Context) error {
+	return ml.waitErr
+}
+
+type mockTransport struct {
+	rtErr error
+}
+
+func (mt mockTransport) RoundTrip(*http.Request) (*http.Response, error) {
+	return nil, mt.rtErr
+}

log.go

@@ -5,10 +5,10 @@ import (
 	"net/http"
 )
 
-// Log adds logging on entry to and exit from an http.Handler.
+// Log adds logging on entry to and exit from an [http.Handler] using [log.Printf].
 //
 // If the request is decorated with a trace ID
-// (see Trace),
+// (see [Trace]),
 // it is included in the generated log lines.
 func Log(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

mid.go

@@ -1,11 +1,9 @@
 // Package mid contains assorted middleware for use in HTTP services.
 package mid
 
-import (
-	"net/http"
-)
+import "net/http"
 
-// ResponseWrapper implements http.ResponseWriter,
+// ResponseWrapper implements [http.ResponseWriter],
 // delegating calls to a wrapped http.ResponseWriter object.
 // It also records the status code and the number of response bytes that have been written.
 type ResponseWrapper struct {

session.go

@@ -10,10 +10,10 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/bobg/errors"
 )
 
-// Session is the type of a session stored in a SessionStore.
+// Session is the type of a session stored in a [SessionStore].
 type Session interface {
 	// CSRFKey is a persistent random bytestring that can be used for CSRF protection.
 	CSRFKey() [sha256.Size]byte
@@ -48,7 +48,7 @@ func CSRFToken(s Session) (string, error) {
 	return base64.RawURLEncoding.EncodeToString(buf[:]), nil
 }
 
-// ErrCSRF is the error produced when an invalid CSRF token is presented to CSRFCheck.
+// ErrCSRF is the error produced when an invalid CSRF token is presented to [CSRFCheck].
 var ErrCSRF = errors.New("CSRF check failed")
 
 // CSRFCheck checks a CSRF token against a session for validity.
@@ -81,13 +81,13 @@ func csrfSum(s Session, inp []byte) ([]byte, error) {
 	return h.Sum(nil), nil
 }
 
-// ErrNoSession is the error produced by SessionStore.Get when no matching session is found.
+// ErrNoSession is the error produced by [SessionStore.Get] when no matching session is found.
 var ErrNoSession = errors.New("no session")
 
 // SessionStore is persistent storage for session objects.
 type SessionStore interface {
 	// Get gets the session with the given key.
-	// If no such session is found, it returns ErrNoSession.
+	// If no such session is found, it returns [ErrNoSession].
 	Get(context.Context, string) (Session, error)
 
 	// Cancel cancels the session with the given unique key.
@@ -106,15 +106,15 @@ func GetSession(ctx context.Context, store SessionStore, cookieName string, req
 	return store.Get(ctx, cookie.Value)
 }
 
-// IsNoSession tests whether the given error is either ErrNoSession or http.ErrNoCookie.
+// IsNoSession tests whether the given error is either [ErrNoSession] or [http.ErrNoCookie].
 func IsNoSession(err error) bool {
 	return errors.Is(err, http.ErrNoCookie) || errors.Is(err, ErrNoSession)
 }
 
-// SessionHandler is an http.Handler middleware wrapper.
+// SessionHandler is an [http.Handler] middleware wrapper.
 // It checks the incoming request for a session in the given store.
 // If one is found, the request's context is decorated with the session.
-// It can be retrieved by the next handler with ContextSession.
+// It can be retrieved by the next handler with [ContextSession].
 // If an active, unexpired session is not found, a 403 Forbidden error is returned.
 func SessionHandler(store SessionStore, cookieName string, next http.Handler) http.Handler {
 	return Err(func(w http.ResponseWriter, req *http.Request) error {
@@ -129,7 +129,7 @@ func SessionHandler(store SessionStore, cookieName string, next http.Handler) ht
 		if !s.Active() || s.Exp().Before(time.Now()) {
 			return CodeErr{C: http.StatusForbidden, Err: fmt.Errorf("session inactive or expired")}
 		}
-		ctx = context.WithValue(ctx, sessKey, s)
+		ctx = context.WithValue(ctx, sessKeyType{}, s)
 		req = req.WithContext(ctx)
 		next.ServeHTTP(w, req)
 		return nil
@@ -138,11 +138,9 @@ func SessionHandler(store SessionStore, cookieName string, next http.Handler) ht
 
 type sessKeyType struct{}
 
-var sessKey sessKeyType
-
-// ContextSession returns the Session associated with a context (by SessionHandler), if there is one.
+// ContextSession returns the [Session] associated with a context (by [SessionHandler]), if there is one.
 // If there isn't, this returns nil.
 func ContextSession(ctx context.Context) Session {
-	s, _ := ctx.Value(sessKey).(Session)
+	s, _ := ctx.Value(sessKeyType{}).(Session)
 	return s
 }