blockpath_test.go

package plugin_blockpath

import (
	"context"
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestNew(t *testing.T) {
	tests := []struct {
		desc    string
		regexps []string
		cfg     *Config
		next    http.Handler
		expErr  bool
	}{
		{
			desc:    "should return no error",
			regexps: []string{`^/foo/(.*)`},
			cfg:     nil,
			next:    http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}),
			expErr:  false,
		},
		{
			desc:    "should return an error",
			regexps: []string{"*"},
			cfg:     nil,
			next:    http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}),
			expErr:  true,
		},
		{
			desc:    "should allow nil config",
			regexps: nil,
			cfg:     nil,
			next:    http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}),
			expErr:  false,
		},
		{
			desc:    "should return an error on nil next",
			regexps: []string{`^/foo/(.*)`},
			cfg:     nil,
			next:    nil,
			expErr:  true,
		},
	}

	for _, test := range tests {
		t.Run(test.desc, func(t *testing.T) {
			cfg := test.cfg
			if cfg == nil && test.regexps != nil {
				cfg = &Config{
					Regex: test.regexps,
				}
			}

			_, err := New(context.Background(), test.next, cfg, "name")
			if test.expErr && err == nil {
				t.Errorf("expected constructor to return an error")
			} else if !test.expErr && err != nil {
				t.Fatalf("unexpected constructor error: %v", err)
			}
		})
	}
}

func TestServeHTTP(t *testing.T) {
	tests := []struct {
		desc          string
		regexps       []string
		reqPath       string
		expNextCall   bool
		expStatusCode int
	}{
		{
			desc:          "should return forbidden status",
			regexps:       []string{"/test"},
			reqPath:       "/test",
			expNextCall:   false,
			expStatusCode: http.StatusForbidden,
		},
		{
			desc:          "should return forbidden status",
			regexps:       []string{"/test", "/toto"},
			reqPath:       "/toto",
			expNextCall:   false,
			expStatusCode: http.StatusForbidden,
		},
		{
			desc:          "should return ok status",
			regexps:       []string{"/test", "/toto"},
			reqPath:       "/plop",
			expNextCall:   true,
			expStatusCode: http.StatusOK,
		},
		{
			desc:          "should return ok status",
			regexps:       nil,
			reqPath:       "/test",
			expNextCall:   true,
			expStatusCode: http.StatusOK,
		},
		{
			desc:          "should return forbidden status",
			regexps:       []string{`^/bar(.*)`},
			reqPath:       "/bar/foo",
			expNextCall:   false,
			expStatusCode: http.StatusForbidden,
		},
		{
			desc:          "should return forbidden status",
			regexps:       []string{`^/bar(.*)`},
			reqPath:       "/foo/bar",
			expNextCall:   true,
			expStatusCode: http.StatusOK,
		},
		{
			desc:          "should block decoded path when request is percent encoded",
			regexps:       []string{`^/foo bar$`},
			reqPath:       "/foo%20bar",
			expNextCall:   false,
			expStatusCode: http.StatusForbidden,
		},
	}

	for _, test := range tests {
		t.Run(test.desc, func(t *testing.T) {
			cfg := &Config{
				Regex: test.regexps,
			}

			nextCall := false
			next := http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {
				nextCall = true
			})

			handler, err := New(context.Background(), next, cfg, "blockpath")
			if err != nil {
				t.Fatal(err)
			}

			recorder := httptest.NewRecorder()

			req := httptest.NewRequest(http.MethodGet, "http://localhost"+test.reqPath, http.NoBody)

			handler.ServeHTTP(recorder, req)

			if nextCall != test.expNextCall {
				t.Errorf("next handler should not be called")
			}

			if recorder.Result().StatusCode != test.expStatusCode {
				t.Errorf("got status code %d, want %d", recorder.Code, test.expStatusCode)
			}
		})
	}
}