func TestPathMatchHandler_BreakCurrentPipeline(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
return nil
}))
h.BreakCurrentPipeline = true
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
breakCurrentPipeline, _ := h.Handle(ctx1)
assert.True(t, breakCurrentPipeline)
h = NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
return nil
}))
h.BreakCurrentPipeline = false
ctx1 = context_test.MakeTestContextWithPath("/collection/123/name")
breakCurrentPipeline, _ = h.Handle(ctx1)
assert.False(t, breakCurrentPipeline)
}
func TestPathMatchHandler(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
var called bool = false
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
called = true
return nil
}))
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
will, _ := h.WillHandle(ctx1)
assert.True(t, will)
h.Handle(ctx1)
assert.True(t, called, "Method should be called")
assert.Equal(t, "123", ctx1.Data().Get(context.DataKeyPathParameters).(objects.Map).Get("id"))
ctx2 := context_test.MakeTestContextWithPath("/collection")
will, _ = h.WillHandle(ctx2)
assert.False(t, will)
assert.Nil(t, ctx2.Data().Get(context.DataKeyPathParameters))
h.BreakCurrentPipeline = true
shouldStop, handleErr := h.Handle(ctx2)
assert.Nil(t, handleErr)
assert.True(t, shouldStop)
assert.True(t, called, "Handler func should get called")
}
func assertPathMatches(t *testing.T, pattern, path string, shouldMatch bool) bool {
pathPattern, _ := paths.NewPathPattern(pattern)
ctx := context_test.MakeTestContextWithPath(path)
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error { return nil }))
willHandle, _ := h.WillHandle(ctx)
return assert.Equal(t, shouldMatch, willHandle, fmt.Sprintf("WillHandle should be %v for '%s' with path '%s'.", shouldMatch, pattern, path))
}
func TestNewPathMatchHandler(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("collection/{id}/name")
var called bool = false
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error {
called = true
return nil
}))
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
will, _ := h.WillHandle(ctx1)
assert.True(t, will)
h.Handle(ctx1)
assert.True(t, called, "Method should be called")
assert.Equal(t, "123", ctx1.Data().Get(context.DataKeyPathParameters).(objects.Map).Get("id"))
}
func TestPathMatches_WithHttpMethod(t *testing.T) {
pathPattern, _ := paths.NewPathPattern("people/123")
h := NewPathMatchHandler(pathPattern, HandlerExecutionFunc(func(c context.Context) error { return nil }))
h.HttpMethods = []string{"POST"}
ctx := context_test.MakeTestContextWithDetails("/people/123", "GET")
willHandle, _ := h.WillHandle(ctx)
assert.Equal(t, false, willHandle)
ctx2 := context_test.MakeTestContextWithDetails("/people/123", "POST")
willHandle, _ = h.WillHandle(ctx2)
assert.Equal(t, true, willHandle)
}
func TestPathMatchHandler_WithMatcherFuncs_Match(t *testing.T) {
matcherFuncCalled := false
handler := new(PathMatchHandler)
handler.PathPattern, _ = paths.NewPathPattern("/specific/things")
handler.ExecutionFunc = HandlerExecutionFunc(func(c context.Context) error {
return nil
})
handler.MatcherFuncs = []MatcherFunc{func(c context.Context) (MatcherFuncDecision, error) {
matcherFuncCalled = true
return Match, nil
}}
ctx1 := context_test.MakeTestContextWithPath("/collection/123/name")
will, _ := handler.WillHandle(ctx1)
assert.True(t, will, "Should want to handle even though the path DOESNT match")
}
// handlerForOptions gets or creates a Handler object based on the specified
// options. See goweb.Map for details of valid options.
func (h *HttpHandler) handlerForOptions(options ...interface{}) (Handler, error) {
if len(options) == 0 {
// no arguments is an error
panic("goweb: Cannot call Map functions with no arguments.")
}
var matcherFuncStartPos int = -1
var methods []string
var path string
var executor HandlerExecutionFunc
switch options[0].(type) {
case string, []string:
switch options[1].(type) {
case nil:
panic("goweb: Cannot call Map with 2nd argument nil.")
case string: // (method|methods, path, executor, ...)
// get the methods from the arguments
switch options[0].(type) {
case []string:
methods = options[0].([]string)
case string:
methods = []string{options[0].(string)}
}
path = options[1].(string)
executor = options[2].(func(context.Context) error)
matcherFuncStartPos = 3
default: // (path, executor, ...)
path = options[0].(string)
executor = options[1].(func(context.Context) error)
matcherFuncStartPos = 2
}
case Handler: // actual handler object
return options[0].(Handler), nil
default: // (executor)
matcherFuncStartPos = 1
path = "***"
executor = options[0].(func(context.Context) error)
}
// collect the matcher funcs
var matcherFuncs []MatcherFunc = findMatcherFuncs(options[matcherFuncStartPos:]...)
pathPattern, pathErr := paths.NewPathPattern(path)
if pathErr != nil {
return nil, pathErr
}
handler := NewPathMatchHandler(pathPattern, executor)
// did they specify a method?
if len(methods) > 0 {
handler.HttpMethods = methods
}
// do we have any MatcherFuncs?
handler.MatcherFuncs = matcherFuncs
// return the handler
return handler, nil
}