woodpecker/vendor/github.com/getsentry/raven-go/http_test.go
2015-09-29 18:21:17 -07:00

149 lines
3.4 KiB
Go

package raven
import (
"net/http"
"net/url"
"reflect"
"testing"
)
type testcase struct {
request *http.Request
*Http
}
func newBaseRequest() *http.Request {
u, _ := url.Parse("http://example.com/")
header := make(http.Header)
header.Add("Foo", "bar")
req := &http.Request{
Method: "GET",
URL: u,
Proto: "HTTP/1.1",
ProtoMajor: 1,
ProtoMinor: 1,
Header: header,
Host: u.Host,
RemoteAddr: "127.0.0.1:8000",
}
return req
}
func newBaseHttp() *Http {
h := &Http{
Method: "GET",
Cookies: "",
Query: "",
URL: "http://example.com/",
Headers: map[string]string{"Foo": "bar"},
Env: map[string]string{"REMOTE_ADDR": "127.0.0.1", "REMOTE_PORT": "8000"},
}
return h
}
func NewRequest() testcase {
return testcase{newBaseRequest(), newBaseHttp()}
}
func NewRequestIPV6() testcase {
req := newBaseRequest()
req.RemoteAddr = "[:1]:8000"
h := newBaseHttp()
h.Env = map[string]string{"REMOTE_ADDR": ":1", "REMOTE_PORT": "8000"}
return testcase{req, h}
}
func NewRequestMultipleHeaders() testcase {
req := newBaseRequest()
req.Header.Add("Foo", "baz")
h := newBaseHttp()
h.Headers["Foo"] = "bar,baz"
return testcase{req, h}
}
func NewSecureRequest() testcase {
req := newBaseRequest()
req.Header.Add("X-Forwarded-Proto", "https")
h := newBaseHttp()
h.URL = "https://example.com/"
h.Headers["X-Forwarded-Proto"] = "https"
return testcase{req, h}
}
func NewCookiesRequest() testcase {
val := "foo=bar; bar=baz"
req := newBaseRequest()
req.Header.Add("Cookie", val)
h := newBaseHttp()
h.Cookies = val
h.Headers["Cookie"] = val
return testcase{req, h}
}
var newHttpTests = []testcase{
NewRequest(),
NewRequestIPV6(),
NewRequestMultipleHeaders(),
NewSecureRequest(),
NewCookiesRequest(),
}
func TestNewHttp(t *testing.T) {
for _, test := range newHttpTests {
actual := NewHttp(test.request)
if actual.Method != test.Method {
t.Errorf("incorrect Method: got %s, want %s", actual.Method, test.Method)
}
if actual.Cookies != test.Cookies {
t.Errorf("incorrect Cookies: got %s, want %s", actual.Cookies, test.Cookies)
}
if actual.Query != test.Query {
t.Errorf("incorrect Query: got %s, want %s", actual.Query, test.Query)
}
if actual.URL != test.URL {
t.Errorf("incorrect URL: got %s, want %s", actual.URL, test.URL)
}
if !reflect.DeepEqual(actual.Headers, test.Headers) {
t.Errorf("incorrect Headers: got %+v, want %+v", actual.Headers, test.Headers)
}
if !reflect.DeepEqual(actual.Env, test.Env) {
t.Errorf("incorrect Env: got %+v, want %+v", actual.Env, test.Env)
}
if !reflect.DeepEqual(actual.Data, test.Data) {
t.Errorf("incorrect Data: got %+v, want %+v", actual.Data, test.Data)
}
}
}
var sanitizeQueryTests = []struct {
input, output string
}{
{"foo=bar", "foo=bar"},
{"password=foo", "password=********"},
{"passphrase=foo", "passphrase=********"},
{"passwd=foo", "passwd=********"},
{"secret=foo", "secret=********"},
{"secretstuff=foo", "secretstuff=********"},
{"foo=bar&secret=foo", "foo=bar&secret=********"},
{"secret=foo&secret=bar", "secret=********"},
}
func parseQuery(q string) url.Values {
r, _ := url.ParseQuery(q)
return r
}
func TestSanitizeQuery(t *testing.T) {
for _, test := range sanitizeQueryTests {
actual := sanitizeQuery(parseQuery(test.input))
expected := parseQuery(test.output)
if !reflect.DeepEqual(actual, expected) {
t.Errorf("incorrect sanitization: got %+v, want %+v", actual, expected)
}
}
}