func (m *Mux) makeContext(r *http.Request) (context.Context, error) {
if m.contextMaker != nil {
ctx, err := m.contextMaker(r)
if err != nil {
return context.Background(), err
}
return ctx, nil
}
return context.Background(), nil
}
func fromValues(t *testing.T, values url.Values) (*rellenv.Env, context.Context) {
req, err := http.NewRequest(
"GET",
"http://www.fbrell.com/?"+values.Encode(),
nil)
if err != nil {
t.Fatalf("Failed to create request: %s", err)
}
env, err := defaultParser().FromRequest(context.Background(), req)
if err != nil {
t.Fatalf("Failed to create env: %s", err)
}
return env, rellenv.WithEnv(context.Background(), env)
}
func TestMuxContextMakerError(t *testing.T) {
givenErr := errors.New("")
var actualErr error
mux, err := ctxmux.New(
ctxmux.MuxContextMaker(func(r *http.Request) (context.Context, error) {
return nil, givenErr
}),
ctxmux.MuxErrorHandler(
func(ctx context.Context, w http.ResponseWriter, r *http.Request, err error) {
ensure.DeepEqual(t, ctx, context.Background())
actualErr = err
}),
)
ensure.Nil(t, err)
hw := httptest.NewRecorder()
hr := &http.Request{
Method: "GET",
URL: &url.URL{
Path: "/",
},
}
mux.GET(hr.URL.Path, func(context.Context, http.ResponseWriter, *http.Request) error {
panic("not reached")
})
mux.ServeHTTP(hw, hr)
ensure.DeepEqual(t, actualErr, givenErr)
}
func TestWrapExistingMultiStackError(t *testing.T) {
err := &multiStackError{
multiStack: new(stack.Multi),
}
we := Wrap(context.Background(), err)
ensure.DeepEqual(t, we, err)
ensure.DeepEqual(t, len(err.multiStack.Stacks()), 1)
}
func TestWrapNewSingleFrame(t *testing.T) {
err := errors.New("")
config := Config{StackMode: StackModeSingleFrame}
ctx := WithConfig(context.Background(), config)
we := Wrap(ctx, err).(*singleFrameError)
ensure.DeepEqual(t, we.config, config)
ensure.DeepEqual(t, we.underlying, err)
ensure.DeepEqual(t, we.frame.Name, "TestWrapNewSingleFrame")
}
func TestWrapNewMultiStackError(t *testing.T) {
err := errors.New("")
config := Config{StackMode: StackModeMultiStack}
ctx := WithConfig(context.Background(), config)
we := Wrap(ctx, err).(*multiStackError)
ensure.DeepEqual(t, we.config, config)
ensure.DeepEqual(t, we.underlying, err)
ensure.DeepEqual(t, we.multiStack.Stacks()[0][0].Name, "TestWrapNewMultiStackError")
}
// Serve HTTP requests for the main port.
func (a *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
a.once.Do(func() {
const public = "/public/"
fileserver := http.FileServer(a.PublicFS)
mux, err := ctxmux.New(
ctxmux.MuxErrorHandler(a.handleError),
ctxmux.MuxNotFoundHandler(a.ExamplesHandler.Example),
ctxmux.MuxRedirectTrailingSlash(),
ctxmux.MuxContextMaker(a.contextMaker),
)
if err != nil {
panic(err)
}
mux.GET(a.Static.Path+"*rest", ctxmux.HTTPHandler(a.Static))
mux.GET("/favicon.ico", ctxmux.HTTPHandler(fileserver))
mux.GET("/f8.jpg", ctxmux.HTTPHandler(fileserver))
mux.GET("/robots.txt", ctxmux.HTTPHandler(fileserver))
mux.GET(public+"*rest", ctxmux.HTTPHandler(http.StripPrefix(public, fileserver)))
mux.GET("/info/*rest", a.ContextHandler.Info)
mux.POST("/info/*rest", a.ContextHandler.Info)
mux.GET("/examples/", a.ExamplesHandler.List)
mux.GET("/saved/:hash", a.ExamplesHandler.GetSaved)
mux.POST("/saved/", a.ExamplesHandler.PostSaved)
mux.GET("/og/*rest", a.OgHandler.Values)
mux.GET("/rog/*rest", a.OgHandler.Base64)
mux.GET("/rog-redirect/*rest", a.OgHandler.Redirect)
mux.GET(oauth.Path+"*rest", a.OauthHandler.Handler)
if a.AdminHandler.Path != "" {
adminPath := path.Join("/", a.AdminHandler.Path) + "/*rest"
mux.GET(adminPath, ctxmux.HTTPHandler(a.AdminHandler))
}
var handler http.Handler
handler = &appdata.Handler{
Handler: mux,
Secret: a.App.SecretByte(),
MaxAge: a.SignedRequestMaxAge,
}
a.mux = handler
a.ctx = context.Background()
a.ctx = ctxerr.WithConfig(a.ctx, ctxerr.Config{
StackMode: ctxerr.StackModeMultiStack,
StringMode: ctxerr.StringModeNone,
})
})
a.mux.ServeHTTP(w, r)
}
func ExampleWithTimeout() {
// Pass a context with a timeout to tell a blocking function that it
// should abandon its work after the timeout elapses.
ctx, _ := context.WithTimeout(context.Background(), 100*time.Millisecond)
select {
case <-time.After(200 * time.Millisecond):
fmt.Println("overslept")
case <-ctx.Done():
fmt.Println(ctx.Err()) // prints "context deadline exceeded"
}
// Output:
// context deadline exceeded
}
func TestParseBase64(t *testing.T) {
t.Parallel()
const song1 = "W1sib2c6dGl0bGUiLCJzb25nMSJdLFsib2c6dHlwZSIsInNvbmciXV0"
expected := &Object{Pairs: []Pair{
{"og:title", "song1"},
{"og:type", "song"},
{"og:url", "http://www.fbrell.com/rog/" + song1},
{"og:image", "http://www.fbrell.com/static/W1siL2ltYWdlcy90YXhpX3JvdGlhXzI4MDYzMzkxMjUuanBnIiwiMTdkMTlmNDUiXV0.jpg"},
{"og:description", stockDescriptions[0]},
}}
object, err := defaultParser().FromBase64(context.Background(), defaultContext, song1)
if err != nil {
t.Fatal(err)
}
assertSubset(t, expected, object)
}
func TestParseValues(t *testing.T) {
t.Parallel()
const ogType = "article"
const ogTitle = "foo"
values := url.Values{}
values.Set("og:type", ogType)
values.Set("og:title", ogTitle)
expected := &Object{Pairs: []Pair{
{"og:type", ogType},
{"og:title", ogTitle},
{"og:url", "http://www.fbrell.com/og/" + ogType + "/" + ogTitle},
{"og:image", "http://www.fbrell.com/static/W1siL2ltYWdlcy90YXhpX3JvdGlhXzI4MDYzMzkxMjUuanBnIiwiMTdkMTlmNDUiXV0.jpg"},
{"og:description", stockDescriptions[6]},
}}
object, err := defaultParser().FromValues(context.Background(), defaultContext, values)
if err != nil {
t.Fatal(err)
}
assertSubset(t, expected, object)
}
func TestWrapMethods(t *testing.T) {
cases := []struct {
Method string
Register func(*ctxmux.Mux, string, ctxmux.Handler)
}{
{Method: "HEAD", Register: (*ctxmux.Mux).HEAD},
{Method: "GET", Register: (*ctxmux.Mux).GET},
{Method: "POST", Register: (*ctxmux.Mux).POST},
{Method: "PUT", Register: (*ctxmux.Mux).PUT},
{Method: "DELETE", Register: (*ctxmux.Mux).DELETE},
{Method: "PATCH", Register: (*ctxmux.Mux).PATCH},
}
const key = int(1)
const val = int(2)
body := []byte("body")
for _, c := range cases {
mux, err := ctxmux.New(
ctxmux.MuxContextMaker(func(r *http.Request) (context.Context, error) {
ctx := context.Background()
return context.WithValue(ctx, key, val), nil
}),
)
ensure.Nil(t, err)
hw := httptest.NewRecorder()
hr := &http.Request{
Method: c.Method,
URL: &url.URL{
Path: "/",
},
}
c.Register(mux, hr.URL.Path, func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
ensure.DeepEqual(t, ctx.Value(key), val)
w.Write(body)
return nil
})
mux.ServeHTTP(hw, hr)
ensure.DeepEqual(t, hw.Body.Bytes(), body)
}
}
func TestWithConfig(t *testing.T) {
ac := Config{StackMode: StackModeMultiStack}
ctx := WithConfig(context.Background(), ac)
ensure.DeepEqual(t, ContextConfig(ctx), ac)
}
func TestContextWithNoParams(t *testing.T) {
var nilParams httprouter.Params
ensure.DeepEqual(t, ctxmux.ContextParams(context.Background()), nilParams)
}
func TestWrapDefaultPassThru(t *testing.T) {
err := errors.New("")
ensure.DeepEqual(t, Wrap(context.Background(), err), err)
}
func TestContextWithFromParams(t *testing.T) {
p := httprouter.Params{}
ctx := ctxmux.WithParams(context.Background(), p)
actual := ctxmux.ContextParams(ctx)
ensure.DeepEqual(t, actual, p)
}
func TestContextConfig(t *testing.T) {
ensure.DeepEqual(t, ContextConfig(context.Background()), Config{})
}
func TestWrapSingleStackErro(t *testing.T) {
err := &singleStackError{}
ensure.DeepEqual(t, Wrap(context.Background(), err), err)
}
func TestWrapNil(t *testing.T) {
ensure.Nil(t, Wrap(context.Background(), nil))
}
