test(middleware): Improves test coverage

middleware/basic_auth_test.go

@@ -0,0 +1,71 @@
+package middleware
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ chi "github.com/go-chi/chi/v5"
+)
+
+var testAuthCreds = map[string]string{
+ "testUser": "testPassword",
+}
+
+func TestBasicAuth(t *testing.T) {
+ r := chi.NewRouter()
+ r.Use(BasicAuth("localhost", testAuthCreds))
+ r.Get("/secure", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("authentication accepted"))
+ }))
+
+ cases := []struct {
+ name string
+ digest string
+ expected int
+ errorMessage string
+ wantErr bool
+ }{
+ {
+ name: "No auth header provided",
+ expected: http.StatusUnauthorized,
+ errorMessage: "basic auth: accepted request without a valid header",
+ wantErr: true,
+ },
+ {
+ name: "Invalid auth header provided",
+ digest: "Basic dGVzdFVzZXI6d3JvbmdwYXNzd29yZA==",
+ expected: http.StatusUnauthorized,
+ errorMessage: "basic auth: accepted invalid bearer token",
+ wantErr: true,
+ },
+ {
+ name: "Valid auth header provided",
+ digest: "Basic dGVzdFVzZXI6dGVzdFBhc3N3b3Jk",
+ expected: http.StatusOK,
+ errorMessage: "basic auth: did not accept a valid bearer token",
+ wantErr: false,
+ },
+ }
+
+ for _, c := range cases {
+ // Record response
+ w := httptest.NewRecorder()
+ req, err := http.NewRequest("GET", "/secure", nil)
+ if err != nil {
+ t.Fatalf("basic auth: failed to create test request")
+ }
+
+ if c.digest != "" {
+ req.Header.Set("Authorization", c.digest)
+ }
+
+ // Serve request
+ r.ServeHTTP(w, req)
+
+ // Test response code
+ if w.Result().StatusCode != c.expected {
+ t.Errorf(c.errorMessage)
+ }
+ }
+}

middleware/clean_path_test.go

@@ -0,0 +1,23 @@
+package middleware
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ chi "github.com/go-chi/chi/v5"
+)
+
+func TestCleanPath(t *testing.T) {
+ r := chi.NewRouter()
+ r.Use(CleanPath)
+ r.Get("/users/1", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/users////1", nil)
+ r.ServeHTTP(w, req)
+
+ if w.Result().StatusCode != http.StatusOK {
+ t.Errorf("clean path: unexpected response code: %v", w.Result().StatusCode)
+ }
+}

middleware/heartbeat_test.go

@@ -0,0 +1,23 @@
+package middleware
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ chi "github.com/go-chi/chi/v5"
+)
+
+func TestHeartbeat(t *testing.T) {
+ r := chi.NewRouter()
+ r.Use(Heartbeat("/ping"))
+ r.Get("/ping", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/ping", nil)
+ r.ServeHTTP(w, req)
+
+ if w.Result().StatusCode != http.StatusOK {
+ t.Errorf("heartbeat: unexpected response code: %v", w.Result().StatusCode)
+ }
+}

middleware/middleware_test.go

@@ -9,8 +9,11 @@ import (
  "path"
  "reflect"
  "runtime"
+ "strings"
  "testing"
  "time"
+
+ chi "github.com/go-chi/chi/v5"
 )
 
 var testdataDir string
@@ -20,6 +23,47 @@ func init() {
  testdataDir = path.Join(path.Dir(filename), "/../testdata")
 }
 
+type customMiddleware struct{}
+
+func (c *customMiddleware) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ for name, headers := range req.Header {
+ if strings.ToLower(name) == "x-custom-header" {
+ if len(headers) == 1 {
+ w.WriteHeader(http.StatusOK)
+ return
+ }
+ }
+ }
+
+ w.WriteHeader(http.StatusUnauthorized)
+}
+
+func TestNew(t *testing.T) {
+ r := chi.NewRouter()
+ r.Use(New(&customMiddleware{}))
+ r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("OK"))
+ })
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/", nil)
+ req.Header.Set("X-Custom-Header", "abc123")
+ r.ServeHTTP(w, req)
+
+ if w.Result().StatusCode != http.StatusOK {
+ t.Errorf("new: middleware was not register in the stack")
+ }
+}
+
+func Test_contextKey_String(t *testing.T) {
+ k := &contextKey{
+ name: "test",
+ }
+ if got := k.String(); got != "chi/middleware context value test" {
+ t.Errorf("got: %q, expected: %q", got, "chi/middleware context value test")
+ }
+}
+
 func TestWrapWriterHTTP2(t *testing.T) {
  handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  if r.Proto != "HTTP/2.0" {

middleware/path_rewrite_test.go

@@ -0,0 +1,26 @@
+package middleware
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ chi "github.com/go-chi/chi/v5"
+)
+
+func TestPathRewrite(t *testing.T) {
+ r := chi.NewRouter()
+ r.Use(PathRewrite("/endpoint", "/v1/endpoint"))
+
+ r.Get("/v1/endpoint", func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("OK"))
+ })
+
+ w := httptest.NewRecorder()
+ req, _ := http.NewRequest("GET", "/endpoint", nil)
+ r.ServeHTTP(w, req)
+
+ if w.Result().StatusCode != http.StatusOK {
+ t.Errorf("path rewrite: unexpected response code: %v", w.Result().StatusCode)
+ }
+}

middleware/terminal_test.go

@@ -0,0 +1,34 @@
+package middleware
+
+import (
+ "bytes"
+ "testing"
+)
+
+func Test_cW(t *testing.T) {
+ cases := []struct {
+ name string
+ useColor bool
+ color []byte
+ s string
+ args []interface{}
+ expected string
+ }{
+ {
+ name: "No color",
+ useColor: false,
+ color: nGreen,
+ s: "no color test",
+ expected: "no color test",
+ },
+ }
+
+ for name, c := range cases {
+ actual := &bytes.Buffer{}
+ cW(actual, c.useColor, c.color, c.s, c.args...)
+
+ if actual.String() != c.expected {
+ t.Errorf("(case %q) unexpected output: got %q, expected: %q", name, actual.String(), c.expected)
+ }
+ }
+}

middleware/value_test.go

@@ -0,0 +1,33 @@
+package middleware
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ chi "github.com/go-chi/chi/v5"
+)
+
+func TestWithValue(t *testing.T) {
+ ctxKey := "customKey"
+ ctxValue := "customValue"
+ request := func() *http.Request {
+ req, _ := http.NewRequest("GET", "/", nil)
+ return req
+ }
+ testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ val := r.Context().Value(ctxKey).(string)
+ w.Write([]byte(val))
+ })
+
+ w := httptest.NewRecorder()
+ r := chi.NewRouter()
+ r.Use(WithValue(ctxKey, ctxValue))
+ r.Get("/", testHandler)
+
+ r.ServeHTTP(w, request())
+
+ if w.Body.String() != ctxValue {
+ t.Errorf("value: context did not contain expected value")
+ }
+}