func TestHandleFunc(t *testing.T) {
wfe := setupWFE(t)
var mux *http.ServeMux
var rw *httptest.ResponseRecorder
var stubCalled bool
runWrappedHandler := func(req *http.Request, allowed ...string) {
mux = http.NewServeMux()
rw = httptest.NewRecorder()
stubCalled = false
wfe.HandleFunc(mux, "/test", func(http.ResponseWriter, *http.Request) {
stubCalled = true
}, allowed...)
req.URL = mustParseURL("/test")
mux.ServeHTTP(rw, req)
}
// Plain requests (no CORS)
type testCase struct {
allowed []string
reqMethod string
shouldSucceed bool
}
var lastNonce string
for _, c := range []testCase{
{[]string{"GET", "POST"}, "GET", true},
{[]string{"GET", "POST"}, "POST", true},
{[]string{"GET"}, "", false},
{[]string{"GET"}, "POST", false},
{[]string{"GET"}, "OPTIONS", false}, // TODO, #469
{[]string{"GET"}, "MAKE-COFFEE", false}, // 405, or 418?
} {
runWrappedHandler(&http.Request{Method: c.reqMethod}, c.allowed...)
test.AssertEquals(t, stubCalled, c.shouldSucceed)
if c.shouldSucceed {
test.AssertEquals(t, rw.Code, http.StatusOK)
} else {
test.AssertEquals(t, rw.Code, http.StatusMethodNotAllowed)
test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), strings.Join(c.allowed, ", "))
test.AssertEquals(t,
rw.Body.String(),
`{"type":"urn:acme:error:malformed","detail":"Method not allowed"}`)
}
nonce := rw.Header().Get("Replay-Nonce")
test.AssertNotEquals(t, nonce, lastNonce)
lastNonce = nonce
}
// Disallowed method returns error JSON in body
runWrappedHandler(&http.Request{Method: "PUT"}, "GET", "POST")
test.AssertEquals(t, rw.Header().Get("Content-Type"), "application/problem+json")
test.AssertEquals(t, rw.Body.String(), `{"type":"urn:acme:error:malformed","detail":"Method not allowed"}`)
test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), "GET, POST")
// Disallowed method special case: response to HEAD has got no body
runWrappedHandler(&http.Request{Method: "HEAD"}, "GET", "POST")
test.AssertEquals(t, stubCalled, false)
test.AssertEquals(t, rw.Body.String(), "")
test.AssertEquals(t, sortHeader(rw.Header().Get("Allow")), "GET, POST")
}
func Use(h *http.ServeMux) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
for _, handler := range handlers {
if !handler(w, r) {
// Abort if function responded with false
return
}
}
h.ServeHTTP(w, r)
}
}
func WithProxyMux(handler http.Handler, mux *http.ServeMux) http.Handler {
if mux == nil {
return handler
}
// register the handler at this stage against everything under slash. More specific paths that get registered will take precedence
// this effectively delegates by default unless something specific gets registered.
mux.Handle("/", handler)
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
mux.ServeHTTP(w, req)
})
}
func HandlerMux(s *http.ServeMux, rules *rules) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
m := NewMobileDetect(r, rules)
if m.IsTablet() {
context.Set(r, "Device", "Tablet")
} else if m.IsMobile() {
context.Set(r, "Device", "Mobile")
} else {
context.Set(r, "Device", "Desktop")
}
s.ServeHTTP(w, r)
})
}
func setupTChan(t *testing.T, mux *http.ServeMux) (string, func()) {
ch := testutils.NewServer(t, testutils.NewOpts().SetServiceName("test"))
handler := func(ctx context.Context, call *tchannel.InboundCall) {
req, err := ReadRequest(call)
if !assert.NoError(t, err, "ReadRequest failed") {
return
}
// Make the HTTP call using the default mux.
writer, finish := ResponseWriter(call.Response())
mux.ServeHTTP(writer, req)
finish()
}
ch.Register(tchannel.HandlerFunc(handler), "http")
return ch.PeerInfo().HostPort, func() { ch.Close() }
}
func NewDigestAuthFilter(myMux *http.ServeMux, tm *JwtManager,
digestRealm string, tlsConfig *tls.Config) http.Handler {
authenticator := auth.NewDigestAuthenticator(digestRealm, func(user, realm string) string {
return getUserString(tlsConfig, user, "digest")
})
newMux := http.NewServeMux()
// Override the builtin wrap function to include our capabilities.
newMux.HandleFunc("/",
authenticator.Wrap(func(w http.ResponseWriter, ar *auth.AuthenticatedRequest) {
t := tm.New(ar.Username)
err := tm.AddTokenInfo(t, w, &ar.Request)
if err != nil {
log.Printf("Add token had issues: %v\n", err)
}
myMux.ServeHTTP(w, &ar.Request)
}))
return newMux
}
revel.TemplateFuncs["javascript_include_tag"] = train.JavascriptTag
revel.TemplateFuncs["stylesheet_link_tag"] = train.StylesheetTag
}
var AssetsFilter = func(c *revel.Controller, fc []revel.Filter) {
if strings.HasPrefix(c.Request.URL.Path, "/assets") {
train.ServeRequest(c.Response.Out, c.Request.Request)
} else {
fc[0](c, fc[1:])
}
}
var AdminFilter = func(c *revel.Controller, fc []revel.Filter) {
if strings.HasPrefix(c.Request.URL.Path, "/admin") {
mux.ServeHTTP(c.Response.Out, c.Request.Request)
} else {
fc[0](c, fc[1:])
}
}
func initAdmin() {
Admin = admin.New(&qor.Config{DB: models.DB})
Publish = publish.New(models.DB)
sorting.RegisterCallbacks(models.DB)
validations.RegisterCallbacks(models.DB)
nodeSelectMeta := &admin.Meta{Name: "NodeId", Type: "select_one", Collection: nodeCollection}
bodyMeta := &admin.Meta{Name: "Body", Type: "text"}
Admin.AddResource(&admin.AssetManager{}, &admin.Config{Invisible: true})
func RootHandler(Layout *template.Template, Exits *Exits, domain *gettext.Domain, Phttp *http.ServeMux, Locales map[string]string) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// serve public files
if len(r.URL.Path) > 1 {
Phttp.ServeHTTP(w, r)
return
}
var (
err error
isTor bool
host string
onOff string
fingerprint string
)
if host, err = GetHost(r); err == nil {
fingerprint, isTor = Exits.IsTor(host)
}
// short circuit for torbutton
if IsParamSet(r, "TorButton") {
WriteHTMLBuf(w, r, Layout, domain, "torbutton.html", Page{IsTor: isTor})
return
}
// try to determine if it's TBB
notTBB := !LikelyTBB(r.UserAgent())
// users shouldn't be relying on check
// to determine the TBB is up-to-date
// always return false to this param
notUpToDate := IsParamSet(r, "uptodate")
// string used for classes and such
// in the template
if isTor {
if notTBB || notUpToDate {
onOff = "not"
} else {
onOff = "on"
}
} else {
onOff = "off"
}
// instance of your page model
p := Page{
isTor,
notUpToDate,
IsParamSet(r, "small"),
notTBB,
fingerprint,
onOff,
Lang(r),
host,
Locales,
}
// render the template
WriteHTMLBuf(w, r, Layout, domain, "index.html", p)
}
}
func RootHandler(Layout *template.Template, Exits *Exits, Phttp *http.ServeMux) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
// serve public files
if len(r.URL.Path) > 1 {
Phttp.ServeHTTP(w, r)
return
}
// get remote ip
host := r.Header.Get("X-Forwarded-For")
var err error
if len(host) == 0 {
host, _, err = net.SplitHostPort(r.RemoteAddr)
}
// determine if we're in Tor
var isTor bool
if err != nil {
isTor = false
} else {
isTor = Exits.IsTor(host)
}
// short circuit for torbutton
if len(r.URL.Query().Get("TorButton")) > 0 {
if err := Layout.ExecuteTemplate(w, "torbutton.html", isTor); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
return
}
// string used for classes and such
// in the template
var onOff string
if isTor {
onOff = "on"
} else {
onOff = "off"
}
small := Small(r)
upToDate := UpToDate(r)
// querystring params
extra := ""
if small {
extra += "&small=1"
}
if !upToDate {
extra += "&uptodate=0"
}
// instance of your page model
p := Page{
isTor,
isTor && !upToDate,
!small,
onOff,
Lang(r),
host,
extra,
Locales,
}
// render the template
if err := Layout.ExecuteTemplate(w, "index.html", p); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
}
