You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
703 lines
18 KiB
703 lines
18 KiB
package handle
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"crypto/tls"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path"
|
|
"testing"
|
|
)
|
|
|
|
var (
|
|
baseDir = "tmp/"
|
|
subDir = "sub/"
|
|
subDeepDir = "sub/deep/"
|
|
tmpIndexName = "index.html"
|
|
tmpFileName = "file.txt"
|
|
tmpBadName = "bad.txt"
|
|
tmpSubIndexName = "sub/index.html"
|
|
tmpSubFileName = "sub/file.txt"
|
|
tmpSubBadName = "sub/bad.txt"
|
|
tmpSubDeepIndexName = "sub/deep/index.html"
|
|
tmpSubDeepFileName = "sub/deep/file.txt"
|
|
tmpSubDeepBadName = "sub/deep/bad.txt"
|
|
tmpNoIndexDir = "noindex/"
|
|
tmpNoIndexName = "noindex/noindex.txt"
|
|
|
|
tmpIndex = "Space: the final frontier"
|
|
tmpFile = "These are the voyages of the starship Enterprise."
|
|
tmpSubIndex = "Its continuing mission:"
|
|
tmpSubFile = "To explore strange new worlds"
|
|
tmpSubDeepIndex = "To seek out new life and new civilizations"
|
|
tmpSubDeepFile = "To boldly go where no one has gone before"
|
|
|
|
nothing = ""
|
|
ok = http.StatusOK
|
|
missing = http.StatusNotFound
|
|
redirect = http.StatusMovedPermanently
|
|
notFound = "404 page not found\n"
|
|
|
|
files = map[string]string{
|
|
baseDir + tmpIndexName: tmpIndex,
|
|
baseDir + tmpFileName: tmpFile,
|
|
baseDir + tmpSubIndexName: tmpSubIndex,
|
|
baseDir + tmpSubFileName: tmpSubFile,
|
|
baseDir + tmpSubDeepIndexName: tmpSubDeepIndex,
|
|
baseDir + tmpSubDeepFileName: tmpSubDeepFile,
|
|
baseDir + tmpNoIndexName: tmpSubDeepFile,
|
|
}
|
|
|
|
serveFileFuncs = []FileServerFunc{
|
|
http.ServeFile,
|
|
WithLogging(http.ServeFile),
|
|
}
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
code := func(m *testing.M) int {
|
|
if err := setup(); nil != err {
|
|
log.Fatalf("While setting up test got: %v\n", err)
|
|
}
|
|
defer teardown()
|
|
return m.Run()
|
|
}(m)
|
|
os.Exit(code)
|
|
}
|
|
|
|
func setup() (err error) {
|
|
for filename, contents := range files {
|
|
if err = os.MkdirAll(path.Dir(filename), 0700); nil != err {
|
|
return
|
|
}
|
|
if err = ioutil.WriteFile(
|
|
filename,
|
|
[]byte(contents),
|
|
0600,
|
|
); nil != err {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func teardown() (err error) {
|
|
return os.RemoveAll("tmp")
|
|
}
|
|
|
|
func TestSetMinimumTLSVersion(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
value uint16
|
|
expected uint16
|
|
}{
|
|
{"Too low", tls.VersionTLS10 - 1, tls.VersionTLS10},
|
|
{"Lower bounds", tls.VersionTLS10, tls.VersionTLS10},
|
|
{"Upper bounds", tls.VersionTLS13, tls.VersionTLS13},
|
|
{"Too high", tls.VersionTLS13 + 1, tls.VersionTLS13},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
SetMinimumTLSVersion(tc.value)
|
|
if tc.expected != minTLSVersion {
|
|
t.Errorf("Expected %d but got %d", tc.expected, minTLSVersion)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWithReferrers(t *testing.T) {
|
|
forbidden := http.StatusForbidden
|
|
|
|
ok1 := "http://valid.com"
|
|
ok2 := "https://valid.com"
|
|
ok3 := "http://localhost"
|
|
bad := "http://other.pl"
|
|
|
|
var noRefer []string
|
|
emptyRefer := []string{}
|
|
onlyNoRefer := []string{""}
|
|
refer := []string{ok1, ok2, ok3}
|
|
noWithRefer := []string{"", ok1, ok2, ok3}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
refers []string
|
|
refer string
|
|
code int
|
|
}{
|
|
{"Nil refer list", noRefer, bad, ok},
|
|
{"Empty refer list", emptyRefer, bad, ok},
|
|
{"Unassigned allowed & unassigned", onlyNoRefer, "", ok},
|
|
{"Unassigned allowed & assigned", onlyNoRefer, bad, forbidden},
|
|
{"Whitelist with unassigned", refer, "", forbidden},
|
|
{"Whitelist with bad", refer, bad, forbidden},
|
|
{"Whitelist with ok1", refer, ok1, ok},
|
|
{"Whitelist with ok2", refer, ok2, ok},
|
|
{"Whitelist with ok3", refer, ok3, ok},
|
|
{"Whitelist and none with unassigned", noWithRefer, "", ok},
|
|
{"Whitelist with bad", noWithRefer, bad, forbidden},
|
|
{"Whitelist with ok1", noWithRefer, ok1, ok},
|
|
{"Whitelist with ok2", noWithRefer, ok2, ok},
|
|
{"Whitelist with ok3", noWithRefer, ok3, ok},
|
|
}
|
|
|
|
success := func(w http.ResponseWriter, r *http.Request, name string) {
|
|
defer r.Body.Close()
|
|
w.WriteHeader(ok)
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
handler := WithReferrers(success, tc.refers)
|
|
|
|
fullpath := "http://localhost/" + tmpIndexName
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
req.Header.Add("Referer", tc.refer)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req, "")
|
|
|
|
resp := w.Result()
|
|
_, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
if tc.code != resp.StatusCode {
|
|
t.Errorf(
|
|
"With referer '%s' in '%v' expected status code %d but got %d",
|
|
tc.refer, tc.refers, tc.code, resp.StatusCode,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBasicWithAndWithoutLogging(t *testing.T) {
|
|
referer := "http://localhost"
|
|
noReferer := ""
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
code int
|
|
refer string
|
|
contents string
|
|
}{
|
|
{"Good base dir", "", ok, referer, tmpIndex},
|
|
{"Good base index", tmpIndexName, redirect, referer, nothing},
|
|
{"Good base file", tmpFileName, ok, referer, tmpFile},
|
|
{"Bad base file", tmpBadName, missing, referer, notFound},
|
|
{"Good subdir dir", subDir, ok, referer, tmpSubIndex},
|
|
{"Good subdir index", tmpSubIndexName, redirect, referer, nothing},
|
|
{"Good subdir file", tmpSubFileName, ok, referer, tmpSubFile},
|
|
{"Good base dir", "", ok, noReferer, tmpIndex},
|
|
{"Good base index", tmpIndexName, redirect, noReferer, nothing},
|
|
{"Good base file", tmpFileName, ok, noReferer, tmpFile},
|
|
{"Bad base file", tmpBadName, missing, noReferer, notFound},
|
|
{"Good subdir dir", subDir, ok, noReferer, tmpSubIndex},
|
|
{"Good subdir index", tmpSubIndexName, redirect, noReferer, nothing},
|
|
{"Good subdir file", tmpSubFileName, ok, noReferer, tmpSubFile},
|
|
}
|
|
|
|
for _, serveFile := range serveFileFuncs {
|
|
handler := Basic(serveFile, baseDir)
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
fullpath := "http://localhost/" + tc.path
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
req.Header.Add("Referer", tc.refer)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req)
|
|
|
|
resp := w.Result()
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
contents := string(body)
|
|
if tc.code != resp.StatusCode {
|
|
t.Errorf(
|
|
"While retrieving %s expected status code of %d but got %d",
|
|
fullpath, tc.code, resp.StatusCode,
|
|
)
|
|
}
|
|
if tc.contents != contents {
|
|
t.Errorf(
|
|
"While retrieving %s expected contents '%s' but got '%s'",
|
|
fullpath, tc.contents, contents,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPrefix(t *testing.T) {
|
|
prefix := "/my/prefix/path/"
|
|
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
code int
|
|
contents string
|
|
}{
|
|
{"Good base dir", prefix, ok, tmpIndex},
|
|
{"Good base index", prefix + tmpIndexName, redirect, nothing},
|
|
{"Good base file", prefix + tmpFileName, ok, tmpFile},
|
|
{"Bad base file", prefix + tmpBadName, missing, notFound},
|
|
{"Good subdir dir", prefix + subDir, ok, tmpSubIndex},
|
|
{"Good subdir index", prefix + tmpSubIndexName, redirect, nothing},
|
|
{"Good subdir file", prefix + tmpSubFileName, ok, tmpSubFile},
|
|
{"Unknown prefix", tmpFileName, missing, notFound},
|
|
}
|
|
|
|
for _, serveFile := range serveFileFuncs {
|
|
handler := Prefix(serveFile, baseDir, prefix)
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
fullpath := "http://localhost" + tc.path
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req)
|
|
|
|
resp := w.Result()
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
contents := string(body)
|
|
if tc.code != resp.StatusCode {
|
|
t.Errorf(
|
|
"While retrieving %s expected status code of %d but got %d",
|
|
fullpath, tc.code, resp.StatusCode,
|
|
)
|
|
}
|
|
if tc.contents != contents {
|
|
t.Errorf(
|
|
"While retrieving %s expected contents '%s' but got '%s'",
|
|
fullpath, tc.contents, contents,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIgnoreIndex(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
code int
|
|
contents string
|
|
}{
|
|
{"Good base dir", "", missing, notFound},
|
|
{"Good base index", tmpIndexName, redirect, nothing},
|
|
{"Good base file", tmpFileName, ok, tmpFile},
|
|
{"Bad base file", tmpBadName, missing, notFound},
|
|
{"Good subdir dir", subDir, missing, notFound},
|
|
{"Good subdir index", tmpSubIndexName, redirect, nothing},
|
|
{"Good subdir file", tmpSubFileName, ok, tmpSubFile},
|
|
}
|
|
|
|
for _, serveFile := range serveFileFuncs {
|
|
handler := IgnoreIndex(Basic(serveFile, baseDir))
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
fullpath := "http://localhost/" + tc.path
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req)
|
|
|
|
resp := w.Result()
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
contents := string(body)
|
|
if tc.code != resp.StatusCode {
|
|
t.Errorf(
|
|
"While retrieving %s expected status code of %d but got %d",
|
|
fullpath, tc.code, resp.StatusCode,
|
|
)
|
|
}
|
|
if tc.contents != contents {
|
|
t.Errorf(
|
|
"While retrieving %s expected contents '%s' but got '%s'",
|
|
fullpath, tc.contents, contents,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPreventListings(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
code int
|
|
contents string
|
|
}{
|
|
{"Good base dir", "", ok, tmpIndex},
|
|
{"Good base index", tmpIndexName, redirect, nothing},
|
|
{"Good base file", tmpFileName, ok, tmpFile},
|
|
{"Bad base file", tmpBadName, missing, notFound},
|
|
{"Good subdir dir", subDir, ok, tmpSubIndex},
|
|
{"Good subdir index", tmpSubIndexName, redirect, nothing},
|
|
{"Good subdir file", tmpSubFileName, ok, tmpSubFile},
|
|
{"Dir without index", tmpNoIndexDir, missing, notFound},
|
|
}
|
|
|
|
for _, serveFile := range serveFileFuncs {
|
|
handler := PreventListings(Basic(serveFile, baseDir), baseDir, "")
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
fullpath := "http://localhost/" + tc.path
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req)
|
|
|
|
resp := w.Result()
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
contents := string(body)
|
|
if tc.code != resp.StatusCode {
|
|
t.Errorf(
|
|
"While retrieving %s expected status code of %d but got %d",
|
|
fullpath, tc.code, resp.StatusCode,
|
|
)
|
|
}
|
|
if tc.contents != contents {
|
|
t.Errorf(
|
|
"While retrieving %s expected contents '%s' but got '%s'",
|
|
fullpath, tc.contents, contents,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAddAccessKey(t *testing.T) {
|
|
// Prepare testing data.
|
|
accessKey := "my-access-key"
|
|
|
|
code := func(path, key string) string {
|
|
data := []byte("/" + path + key)
|
|
fmt.Printf("TEST: '%s'\n", data)
|
|
return fmt.Sprintf("%X", md5.Sum(data))
|
|
}
|
|
|
|
// Define test cases.
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
key string
|
|
value string
|
|
code int
|
|
contents string
|
|
}{
|
|
{
|
|
"Good base file with code", tmpFileName,
|
|
"code", code(tmpFileName, accessKey),
|
|
ok, tmpFile,
|
|
},
|
|
{
|
|
"Good base file with key", tmpFileName,
|
|
"key", accessKey,
|
|
ok, tmpFile,
|
|
},
|
|
{
|
|
"Bad base file with code", tmpBadName,
|
|
"code", code(tmpBadName, accessKey),
|
|
missing, notFound,
|
|
},
|
|
{
|
|
"Bad base file with key", tmpBadName,
|
|
"key", accessKey,
|
|
missing, notFound,
|
|
},
|
|
{
|
|
"Good base file with no code or key", tmpFileName,
|
|
"my", "value",
|
|
missing, notFound,
|
|
},
|
|
{
|
|
"Good base file with bad code", tmpFileName,
|
|
"code", code(tmpFileName, "bad-access-key"),
|
|
missing, notFound,
|
|
},
|
|
{
|
|
"Good base file with bad key", tmpFileName,
|
|
"key", "bad-access-key",
|
|
missing, notFound,
|
|
},
|
|
}
|
|
|
|
for _, serveFile := range serveFileFuncs {
|
|
handler := AddAccessKey(Basic(serveFile, baseDir), accessKey)
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
fullpath := fmt.Sprintf(
|
|
"http://localhost/%s?%s=%s",
|
|
tc.path, tc.key, tc.value,
|
|
)
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req)
|
|
|
|
resp := w.Result()
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
contents := string(body)
|
|
if tc.code != resp.StatusCode {
|
|
t.Errorf(
|
|
"While retrieving %s expected status code of %d but got %d",
|
|
fullpath, tc.code, resp.StatusCode,
|
|
)
|
|
}
|
|
if tc.contents != contents {
|
|
t.Errorf(
|
|
"While retrieving %s expected contents '%s' but got '%s'",
|
|
fullpath, tc.contents, contents,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListening(t *testing.T) {
|
|
// Choose values for testing.
|
|
called := false
|
|
testBinding := "host:port"
|
|
testError := errors.New("random problem")
|
|
|
|
// Create an empty placeholder router function.
|
|
handler := func(http.ResponseWriter, *http.Request) {}
|
|
|
|
// Override setHandler so that multiple calls to 'http.HandleFunc' doesn't
|
|
// panic.
|
|
setHandler = func(string, func(http.ResponseWriter, *http.Request)) {}
|
|
|
|
// Override listenAndServe with a function with more introspection and
|
|
// control than 'http.ListenAndServe'.
|
|
listenAndServe = func(
|
|
binding string, handler http.Handler,
|
|
) error {
|
|
if testBinding != binding {
|
|
t.Errorf(
|
|
"While serving expected binding of %s but got %s",
|
|
testBinding, binding,
|
|
)
|
|
}
|
|
called = !called
|
|
if called {
|
|
return nil
|
|
}
|
|
return testError
|
|
}
|
|
|
|
// Perform test.
|
|
listener := Listening()
|
|
if err := listener(testBinding, handler); nil != err {
|
|
t.Errorf("While serving first expected nil error but got %v", err)
|
|
}
|
|
if err := listener(testBinding, handler); nil == err {
|
|
t.Errorf(
|
|
"While serving second got nil while expecting %v", testError,
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestTLSListening(t *testing.T) {
|
|
// Choose values for testing.
|
|
called := false
|
|
testBinding := "host:port"
|
|
testTLSCert := "test/file.pem"
|
|
testTLSKey := "test/file.key"
|
|
testError := errors.New("random problem")
|
|
|
|
// Create an empty placeholder router function.
|
|
handler := func(http.ResponseWriter, *http.Request) {}
|
|
|
|
// Override setHandler so that multiple calls to 'http.HandleFunc' doesn't
|
|
// panic.
|
|
setHandler = func(string, func(http.ResponseWriter, *http.Request)) {}
|
|
|
|
// Override listenAndServeTLS with a function with more introspection and
|
|
// control than 'http.ListenAndServeTLS'.
|
|
listenAndServeTLS = func(
|
|
binding, tlsCert, tlsKey string, handler http.Handler,
|
|
) error {
|
|
if testBinding != binding {
|
|
t.Errorf(
|
|
"While serving TLS expected binding of %s but got %s",
|
|
testBinding, binding,
|
|
)
|
|
}
|
|
if testTLSCert != tlsCert {
|
|
t.Errorf(
|
|
"While serving TLS expected TLS cert of %s but got %s",
|
|
testTLSCert, tlsCert,
|
|
)
|
|
}
|
|
if testTLSKey != tlsKey {
|
|
t.Errorf(
|
|
"While serving TLS expected TLS key of %s but got %s",
|
|
testTLSKey, tlsKey,
|
|
)
|
|
}
|
|
called = !called
|
|
if called {
|
|
return nil
|
|
}
|
|
return testError
|
|
}
|
|
|
|
// Perform test.
|
|
listener := TLSListening(testTLSCert, testTLSKey)
|
|
if err := listener(testBinding, handler); nil != err {
|
|
t.Errorf("While serving first TLS expected nil error but got %v", err)
|
|
}
|
|
if err := listener(testBinding, handler); nil == err {
|
|
t.Errorf(
|
|
"While serving second TLS got nil while expecting %v", testError,
|
|
)
|
|
}
|
|
}
|
|
|
|
func TestValidReferrer(t *testing.T) {
|
|
ok1 := "http://valid.com"
|
|
ok2 := "https://valid.com"
|
|
ok3 := "http://localhost"
|
|
bad := "http://other.pl"
|
|
|
|
var noRefer []string
|
|
emptyRefer := []string{}
|
|
onlyNoRefer := []string{""}
|
|
refer := []string{ok1, ok2, ok3}
|
|
noWithRefer := []string{"", ok1, ok2, ok3}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
refers []string
|
|
refer string
|
|
result bool
|
|
}{
|
|
{"Nil refer list", noRefer, bad, true},
|
|
{"Empty refer list", emptyRefer, bad, true},
|
|
{"Unassigned allowed & unassigned", onlyNoRefer, "", true},
|
|
{"Unassigned allowed & assigned", onlyNoRefer, bad, false},
|
|
{"Whitelist with unassigned", refer, "", false},
|
|
{"Whitelist with bad", refer, bad, false},
|
|
{"Whitelist with ok1", refer, ok1, true},
|
|
{"Whitelist with ok2", refer, ok2, true},
|
|
{"Whitelist with ok3", refer, ok3, true},
|
|
{"Whitelist and none with unassigned", noWithRefer, "", true},
|
|
{"Whitelist with bad", noWithRefer, bad, false},
|
|
{"Whitelist with ok1", noWithRefer, ok1, true},
|
|
{"Whitelist with ok2", noWithRefer, ok2, true},
|
|
{"Whitelist with ok3", noWithRefer, ok3, true},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
result := validReferrer(tc.refers, tc.refer)
|
|
if result != tc.result {
|
|
t.Errorf(
|
|
"With referrers of '%v' and a value of '%s' expected %t but got %t",
|
|
tc.refers, tc.refer, tc.result, result,
|
|
)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAddCorsWildcardHeaders(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
corsEnabled bool
|
|
}{
|
|
{"CORS disabled", false},
|
|
{"CORS enabled", true},
|
|
}
|
|
|
|
corsHeaders := map[string]string{
|
|
"Access-Control-Allow-Origin": "*",
|
|
"Access-Control-Allow-Headers": "*",
|
|
}
|
|
|
|
for _, serveFile := range serveFileFuncs {
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
var handler http.HandlerFunc
|
|
if tc.corsEnabled {
|
|
handler = AddCorsWildcardHeaders(Basic(serveFile, baseDir))
|
|
} else {
|
|
handler = Basic(serveFile, baseDir)
|
|
}
|
|
|
|
fullpath := "http://localhost/" + tmpFileName
|
|
req := httptest.NewRequest("GET", fullpath, nil)
|
|
w := httptest.NewRecorder()
|
|
|
|
handler(w, req)
|
|
|
|
resp := w.Result()
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
if nil != err {
|
|
t.Errorf("While reading body got %v", err)
|
|
}
|
|
contents := string(body)
|
|
if ok != resp.StatusCode {
|
|
t.Errorf(
|
|
"While retrieving %s expected status code of %d but got %d",
|
|
fullpath, ok, resp.StatusCode,
|
|
)
|
|
}
|
|
if tmpFile != contents {
|
|
t.Errorf(
|
|
"While retrieving %s expected contents '%s' but got '%s'",
|
|
fullpath, tmpFile, contents,
|
|
)
|
|
}
|
|
|
|
if tc.corsEnabled {
|
|
for k, v := range corsHeaders {
|
|
if v != resp.Header.Get(k) {
|
|
t.Errorf(
|
|
"With CORS enabled expect header '%s' to return '%s' but got '%s'",
|
|
k, v, resp.Header.Get(k),
|
|
)
|
|
}
|
|
}
|
|
} else {
|
|
for k := range corsHeaders {
|
|
if "" != resp.Header.Get(k) {
|
|
t.Errorf(
|
|
"With CORS disabled expected header '%s' to return '' but got '%s'",
|
|
k, resp.Header.Get(k),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|