mirror of
https://github.com/caddyserver/caddy.git
synced 2025-10-28 09:12:52 -04:00
30c14084ab
* Fix crash when specifying "*" to header directive. Fixes #3060 * Look Host header in header and header_regexp. Also, if more than one header is provided, header_regexp now looks for extra headers values to reflect the behavior from header. Fixes #3059 * Fix parsing of named header_regexp in Caddyfile. See #3059
837 lines
20 KiB
Go
837 lines
20 KiB
Go
// Copyright 2015 Matthew Holt and The Caddy Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package caddyhttp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/caddyserver/caddy/v2"
|
|
)
|
|
|
|
func TestHostMatcher(t *testing.T) {
|
|
err := os.Setenv("GO_BENCHMARK_DOMAIN", "localhost")
|
|
if err != nil {
|
|
t.Errorf("error while setting up environment: %v", err)
|
|
}
|
|
|
|
for i, tc := range []struct {
|
|
match MatchHost
|
|
input string
|
|
expect bool
|
|
}{
|
|
{
|
|
match: MatchHost{},
|
|
input: "example.com",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHost{"example.com"},
|
|
input: "example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"EXAMPLE.COM"},
|
|
input: "example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"example.com"},
|
|
input: "EXAMPLE.COM",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"example.com"},
|
|
input: "foo.example.com",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHost{"example.com"},
|
|
input: "EXAMPLE.COM",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"foo.example.com"},
|
|
input: "foo.example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"foo.example.com"},
|
|
input: "bar.example.com",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.com"},
|
|
input: "example.com",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.com"},
|
|
input: "SUB.EXAMPLE.COM",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.com"},
|
|
input: "foo.example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.com"},
|
|
input: "foo.bar.example.com",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.com", "example.net"},
|
|
input: "example.net",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"example.net", "*.example.com"},
|
|
input: "foo.example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.net", "*.*.example.com"},
|
|
input: "foo.bar.example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.net", "sub.*.example.com"},
|
|
input: "sub.foo.example.com",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"*.example.net", "sub.*.example.com"},
|
|
input: "sub.foo.example.net",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHost{"example.com"},
|
|
input: "example.com:5555",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"{env.GO_BENCHMARK_DOMAIN}"},
|
|
input: "localhost",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHost{"{env.GO_NONEXISTENT}"},
|
|
input: "localhost",
|
|
expect: false,
|
|
},
|
|
} {
|
|
req := &http.Request{Host: tc.input}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d %v: Expected %t, got %t for '%s'", i, tc.match, tc.expect, actual, tc.input)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPathMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
match MatchPath
|
|
input string
|
|
expect bool
|
|
}{
|
|
{
|
|
match: MatchPath{},
|
|
input: "/",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"/"},
|
|
input: "/",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar"},
|
|
input: "/",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar"},
|
|
input: "/foo/bar",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar/"},
|
|
input: "/foo/bar",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar/"},
|
|
input: "/foo/bar/",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar/", "/other"},
|
|
input: "/other/",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar/", "/other"},
|
|
input: "/other",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"*.ext"},
|
|
input: "/foo/bar.ext",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"*.php"},
|
|
input: "/index.PHP",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"*.ext"},
|
|
input: "/foo/bar.ext",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/*/baz"},
|
|
input: "/foo/bar/baz",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/*/baz/bam"},
|
|
input: "/foo/bar/bam",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"*substring*"},
|
|
input: "/foo/substring/bar.txt",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo"},
|
|
input: "/foo/bar",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo"},
|
|
input: "/foo/bar",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo"},
|
|
input: "/FOO",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo*"},
|
|
input: "/FOOOO",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPath{"/foo/bar.txt"},
|
|
input: "/foo/BAR.txt",
|
|
expect: true,
|
|
},
|
|
} {
|
|
req := &http.Request{URL: &url.URL{Path: tc.input}}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d %v: Expected %t, got %t for '%s'", i, tc.match, tc.expect, actual, tc.input)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPathMatcherWindows(t *testing.T) {
|
|
// only Windows has this bug where it will ignore
|
|
// trailing dots and spaces in a filename, but we
|
|
// test for it on all platforms to be more consistent
|
|
|
|
req := &http.Request{URL: &url.URL{Path: "/index.php . . .."}}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
|
|
match := MatchPath{"*.php"}
|
|
matched := match.Match(req)
|
|
if !matched {
|
|
t.Errorf("Expected to match; should ignore trailing dots and spaces")
|
|
}
|
|
}
|
|
|
|
func TestPathREMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
match MatchPathRE
|
|
input string
|
|
expect bool
|
|
expectRepl map[string]string
|
|
}{
|
|
{
|
|
match: MatchPathRE{},
|
|
input: "/",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "/"}},
|
|
input: "/",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "/foo"}},
|
|
input: "/foo",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "/foo"}},
|
|
input: "/foo/",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "/bar"}},
|
|
input: "/foo/",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "^/bar"}},
|
|
input: "/foo/bar",
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "^/foo/(.*)/baz$", Name: "name"}},
|
|
input: "/foo/bar/baz",
|
|
expect: true,
|
|
expectRepl: map[string]string{"name.1": "bar"},
|
|
},
|
|
{
|
|
match: MatchPathRE{MatchRegexp{Pattern: "^/foo/(?P<myparam>.*)/baz$", Name: "name"}},
|
|
input: "/foo/bar/baz",
|
|
expect: true,
|
|
expectRepl: map[string]string{"name.myparam": "bar"},
|
|
},
|
|
} {
|
|
// compile the regexp and validate its name
|
|
err := tc.match.Provision(caddy.Context{})
|
|
if err != nil {
|
|
t.Errorf("Test %d %v: Provisioning: %v", i, tc.match, err)
|
|
continue
|
|
}
|
|
err = tc.match.Validate()
|
|
if err != nil {
|
|
t.Errorf("Test %d %v: Validating: %v", i, tc.match, err)
|
|
continue
|
|
}
|
|
|
|
// set up the fake request and its Replacer
|
|
req := &http.Request{URL: &url.URL{Path: tc.input}}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
addHTTPVarsToReplacer(repl, req, httptest.NewRecorder())
|
|
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d [%v]: Expected %t, got %t for input '%s'",
|
|
i, tc.match.Pattern, tc.expect, actual, tc.input)
|
|
continue
|
|
}
|
|
|
|
for key, expectVal := range tc.expectRepl {
|
|
placeholder := fmt.Sprintf("{http.regexp.%s}", key)
|
|
actualVal := repl.ReplaceAll(placeholder, "<empty>")
|
|
if actualVal != expectVal {
|
|
t.Errorf("Test %d [%v]: Expected placeholder {http.regexp.%s} to be '%s' but got '%s'",
|
|
i, tc.match.Pattern, key, expectVal, actualVal)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHeaderMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
match MatchHeader
|
|
input http.Header // make sure these are canonical cased (std lib will do that in a real request)
|
|
host string
|
|
expect bool
|
|
}{
|
|
{
|
|
match: MatchHeader{"Field": []string{"foo"}},
|
|
input: http.Header{"Field": []string{"foo"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"Field": []string{"foo", "bar"}},
|
|
input: http.Header{"Field": []string{"bar"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"Field": []string{"foo", "bar"}},
|
|
input: http.Header{"Alakazam": []string{"kapow"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHeader{"Field": []string{"foo", "bar"}},
|
|
input: http.Header{"Field": []string{"kapow"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHeader{"Field": []string{"foo", "bar"}},
|
|
input: http.Header{"Field": []string{"kapow", "foo"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"Field1": []string{"foo"}, "Field2": []string{"bar"}},
|
|
input: http.Header{"Field1": []string{"foo"}, "Field2": []string{"bar"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"field1": []string{"foo"}, "field2": []string{"bar"}},
|
|
input: http.Header{"Field1": []string{"foo"}, "Field2": []string{"bar"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"field1": []string{"foo"}, "field2": []string{"bar"}},
|
|
input: http.Header{"Field1": []string{"foo"}, "Field2": []string{"kapow"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHeader{"field1": []string{"*"}},
|
|
input: http.Header{"Field1": []string{"foo"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"field1": []string{"*"}},
|
|
input: http.Header{"Field2": []string{"foo"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHeader{"host": []string{"localhost"}},
|
|
input: http.Header{},
|
|
host: "localhost",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeader{"host": []string{"localhost"}},
|
|
input: http.Header{},
|
|
host: "caddyserver.com",
|
|
expect: false,
|
|
},
|
|
} {
|
|
req := &http.Request{Header: tc.input, Host: tc.host}
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d %v: Expected %t, got %t for '%s'", i, tc.match, tc.expect, actual, tc.input)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestQueryMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
scenario string
|
|
match MatchQuery
|
|
input string
|
|
expect bool
|
|
}{
|
|
{
|
|
scenario: "non match against a specific value",
|
|
match: MatchQuery{"debug": []string{"1"}},
|
|
input: "/",
|
|
expect: false,
|
|
},
|
|
{
|
|
scenario: "match against a specific value",
|
|
match: MatchQuery{"debug": []string{"1"}},
|
|
input: "/?debug=1",
|
|
expect: true,
|
|
},
|
|
{
|
|
scenario: "match against a wildcard",
|
|
match: MatchQuery{"debug": []string{"*"}},
|
|
input: "/?debug=something",
|
|
expect: true,
|
|
},
|
|
{
|
|
scenario: "non match against a wildcarded",
|
|
match: MatchQuery{"debug": []string{"*"}},
|
|
input: "/?other=something",
|
|
expect: false,
|
|
},
|
|
{
|
|
scenario: "match against an empty value",
|
|
match: MatchQuery{"debug": []string{""}},
|
|
input: "/?debug",
|
|
expect: true,
|
|
},
|
|
{
|
|
scenario: "non match against an empty value",
|
|
match: MatchQuery{"debug": []string{""}},
|
|
input: "/?someparam",
|
|
expect: false,
|
|
},
|
|
} {
|
|
|
|
u, _ := url.Parse(tc.input)
|
|
|
|
req := &http.Request{URL: u}
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d %v: Expected %t, got %t for '%s'", i, tc.match, tc.expect, actual, tc.input)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHeaderREMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
match MatchHeaderRE
|
|
input http.Header // make sure these are canonical cased (std lib will do that in a real request)
|
|
host string
|
|
expect bool
|
|
expectRepl map[string]string
|
|
}{
|
|
{
|
|
match: MatchHeaderRE{"Field": &MatchRegexp{Pattern: "foo"}},
|
|
input: http.Header{"Field": []string{"foo"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeaderRE{"Field": &MatchRegexp{Pattern: "$foo^"}},
|
|
input: http.Header{"Field": []string{"foobar"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
match: MatchHeaderRE{"Field": &MatchRegexp{Pattern: "^foo(.*)$", Name: "name"}},
|
|
input: http.Header{"Field": []string{"foobar"}},
|
|
expect: true,
|
|
expectRepl: map[string]string{"name.1": "bar"},
|
|
},
|
|
{
|
|
match: MatchHeaderRE{"Field": &MatchRegexp{Pattern: "^foo.*$", Name: "name"}},
|
|
input: http.Header{"Field": []string{"barfoo", "foobar"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeaderRE{"host": &MatchRegexp{Pattern: "^localhost$", Name: "name"}},
|
|
input: http.Header{},
|
|
host: "localhost",
|
|
expect: true,
|
|
},
|
|
{
|
|
match: MatchHeaderRE{"host": &MatchRegexp{Pattern: "^local$", Name: "name"}},
|
|
input: http.Header{},
|
|
host: "localhost",
|
|
expect: false,
|
|
},
|
|
} {
|
|
// compile the regexp and validate its name
|
|
err := tc.match.Provision(caddy.Context{})
|
|
if err != nil {
|
|
t.Errorf("Test %d %v: Provisioning: %v", i, tc.match, err)
|
|
continue
|
|
}
|
|
err = tc.match.Validate()
|
|
if err != nil {
|
|
t.Errorf("Test %d %v: Validating: %v", i, tc.match, err)
|
|
continue
|
|
}
|
|
|
|
// set up the fake request and its Replacer
|
|
req := &http.Request{Header: tc.input, URL: new(url.URL), Host: tc.host}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
addHTTPVarsToReplacer(repl, req, httptest.NewRecorder())
|
|
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d [%v]: Expected %t, got %t for input '%s'",
|
|
i, tc.match, tc.expect, actual, tc.input)
|
|
continue
|
|
}
|
|
|
|
for key, expectVal := range tc.expectRepl {
|
|
placeholder := fmt.Sprintf("{http.regexp.%s}", key)
|
|
actualVal := repl.ReplaceAll(placeholder, "<empty>")
|
|
if actualVal != expectVal {
|
|
t.Errorf("Test %d [%v]: Expected placeholder {http.regexp.%s} to be '%s' but got '%s'",
|
|
i, tc.match, key, expectVal, actualVal)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVarREMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
desc string
|
|
match MatchVarsRE
|
|
input VarsMiddleware
|
|
expect bool
|
|
expectRepl map[string]string
|
|
}{
|
|
{
|
|
desc: "match static value within var set by the VarsMiddleware succeeds",
|
|
match: MatchVarsRE{"Var1": &MatchRegexp{Pattern: "foo"}},
|
|
input: VarsMiddleware{"Var1": "here is foo val"},
|
|
expect: true,
|
|
},
|
|
{
|
|
desc: "value set by VarsMiddleware not satisfying regexp matcher fails to match",
|
|
match: MatchVarsRE{"Var1": &MatchRegexp{Pattern: "$foo^"}},
|
|
input: VarsMiddleware{"Var1": "foobar"},
|
|
expect: false,
|
|
},
|
|
{
|
|
desc: "successfully matched value is captured and its placeholder is added to replacer",
|
|
match: MatchVarsRE{"Var1": &MatchRegexp{Pattern: "^foo(.*)$", Name: "name"}},
|
|
input: VarsMiddleware{"Var1": "foobar"},
|
|
expect: true,
|
|
expectRepl: map[string]string{"name.1": "bar"},
|
|
},
|
|
{
|
|
desc: "matching against a value of standard variables succeeds",
|
|
match: MatchVarsRE{"{http.request.method}": &MatchRegexp{Pattern: "^G.[tT]$"}},
|
|
input: VarsMiddleware{},
|
|
expect: true,
|
|
},
|
|
{
|
|
desc: "matching against value of var set by the VarsMiddleware and referenced by its placeholder succeeds",
|
|
match: MatchVarsRE{"{http.vars.Var1}": &MatchRegexp{Pattern: "[vV]ar[0-9]"}},
|
|
input: VarsMiddleware{"Var1": "var1Value"},
|
|
expect: true,
|
|
},
|
|
} {
|
|
tc := tc // capture range value
|
|
t.Run(tc.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
// compile the regexp and validate its name
|
|
err := tc.match.Provision(caddy.Context{})
|
|
if err != nil {
|
|
t.Errorf("Test %d %v: Provisioning: %v", i, tc.match, err)
|
|
return
|
|
}
|
|
err = tc.match.Validate()
|
|
if err != nil {
|
|
t.Errorf("Test %d %v: Validating: %v", i, tc.match, err)
|
|
return
|
|
}
|
|
|
|
// set up the fake request and its Replacer
|
|
req := &http.Request{URL: new(url.URL), Method: http.MethodGet}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
ctx = context.WithValue(ctx, VarsCtxKey, make(map[string]interface{}))
|
|
req = req.WithContext(ctx)
|
|
|
|
addHTTPVarsToReplacer(repl, req, httptest.NewRecorder())
|
|
|
|
tc.input.ServeHTTP(httptest.NewRecorder(), req, emptyHandler)
|
|
|
|
actual := tc.match.Match(req)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d [%v]: Expected %t, got %t for input '%s'",
|
|
i, tc.match, tc.expect, actual, tc.input)
|
|
return
|
|
}
|
|
|
|
for key, expectVal := range tc.expectRepl {
|
|
placeholder := fmt.Sprintf("{http.regexp.%s}", key)
|
|
actualVal := repl.ReplaceAll(placeholder, "<empty>")
|
|
if actualVal != expectVal {
|
|
t.Errorf("Test %d [%v]: Expected placeholder {http.regexp.%s} to be '%s' but got '%s'",
|
|
i, tc.match, key, expectVal, actualVal)
|
|
return
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResponseMatcher(t *testing.T) {
|
|
for i, tc := range []struct {
|
|
require ResponseMatcher
|
|
status int
|
|
hdr http.Header // make sure these are canonical cased (std lib will do that in a real request)
|
|
expect bool
|
|
}{
|
|
{
|
|
require: ResponseMatcher{},
|
|
status: 200,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{200},
|
|
},
|
|
status: 200,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{2},
|
|
},
|
|
status: 200,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{201},
|
|
},
|
|
status: 200,
|
|
expect: false,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{2},
|
|
},
|
|
status: 301,
|
|
expect: false,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{3},
|
|
},
|
|
status: 301,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{3},
|
|
},
|
|
status: 399,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{3},
|
|
},
|
|
status: 400,
|
|
expect: false,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{3, 4},
|
|
},
|
|
status: 400,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
StatusCode: []int{3, 401},
|
|
},
|
|
status: 401,
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
Headers: http.Header{
|
|
"Foo": []string{"bar"},
|
|
},
|
|
},
|
|
hdr: http.Header{"Foo": []string{"bar"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
Headers: http.Header{
|
|
"Foo2": []string{"bar"},
|
|
},
|
|
},
|
|
hdr: http.Header{"Foo": []string{"bar"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
Headers: http.Header{
|
|
"Foo": []string{"bar", "baz"},
|
|
},
|
|
},
|
|
hdr: http.Header{"Foo": []string{"baz"}},
|
|
expect: true,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
Headers: http.Header{
|
|
"Foo": []string{"bar"},
|
|
"Foo2": []string{"baz"},
|
|
},
|
|
},
|
|
hdr: http.Header{"Foo": []string{"baz"}},
|
|
expect: false,
|
|
},
|
|
{
|
|
require: ResponseMatcher{
|
|
Headers: http.Header{
|
|
"Foo": []string{"bar"},
|
|
"Foo2": []string{"baz"},
|
|
},
|
|
},
|
|
hdr: http.Header{"Foo": []string{"bar"}, "Foo2": []string{"baz"}},
|
|
expect: true,
|
|
},
|
|
} {
|
|
actual := tc.require.Match(tc.status, tc.hdr)
|
|
if actual != tc.expect {
|
|
t.Errorf("Test %d %v: Expected %t, got %t for HTTP %d %v", i, tc.require, tc.expect, actual, tc.status, tc.hdr)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkHostMatcherWithoutPlaceholder(b *testing.B) {
|
|
req := &http.Request{Host: "localhost"}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
|
|
match := MatchHost{"localhost"}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
match.Match(req)
|
|
}
|
|
}
|
|
|
|
func BenchmarkHostMatcherWithPlaceholder(b *testing.B) {
|
|
err := os.Setenv("GO_BENCHMARK_DOMAIN", "localhost")
|
|
if err != nil {
|
|
b.Errorf("error while setting up environment: %v", err)
|
|
}
|
|
|
|
req := &http.Request{Host: "localhost"}
|
|
repl := caddy.NewReplacer()
|
|
ctx := context.WithValue(req.Context(), caddy.ReplacerCtxKey, repl)
|
|
req = req.WithContext(ctx)
|
|
match := MatchHost{"{env.GO_BENCHMARK_DOMAIN}"}
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
match.Match(req)
|
|
}
|
|
}
|