mirror of
https://github.com/labstack/echo.git
synced 2024-12-22 20:06:21 +02:00
6ef5f77bf2
WIP: make default logger implemented custom writer for jsonlike logs WIP: improve examples WIP: defaultErrorHandler use errors.As to unwrap errors. Update readme WIP: default logger logs json, restore e.Start method WIP: clean router.Match a bit WIP: func types/fields have echo.Context has first element WIP: remove yaml tags as functions etc can not be serialized anyway WIP: change BindPathParams,BindQueryParams,BindHeaders from methods to functions and reverse arguments to be like DefaultBinder.Bind is WIP: improved comments, logger now extracts status from error WIP: go mod tidy WIP: rebase with 4.5.0 WIP: * removed todos. * removed StartAutoTLS and StartH2CServer methods from `StartConfig` * KeyAuth middleware errorhandler can swallow the error and resume next middleware WIP: add RouterConfig.UseEscapedPathForMatching to use escaped path for matching request against routes WIP: FIXMEs WIP: upgrade golang-jwt/jwt to `v4` WIP: refactor http methods to return RouteInfo WIP: refactor static not creating multiple routes WIP: refactor route and middleware adding functions not to return error directly WIP: Use 401 for problematic/missing headers for key auth and JWT middleware (#1552, #1402). > In summary, a 401 Unauthorized response should be used for missing or bad authentication WIP: replace `HTTPError.SetInternal` with `HTTPError.WithInternal` so we could not mutate global error variables WIP: add RouteInfo and RouteMatchType into Context what we could know from in middleware what route was matched and/or type of that match (200/404/405) WIP: make notFoundHandler and methodNotAllowedHandler private. encourage that all errors be handled in Echo.HTTPErrorHandler WIP: server cleanup ideas WIP: routable.ForGroup WIP: note about logger middleware WIP: bind should not default values on second try. use crypto rand for better randomness WIP: router add route as interface and returns info as interface WIP: improve flaky test (remains still flaky) WIP: add notes about bind default values WIP: every route can have their own path params names WIP: routerCreator and different tests WIP: different things WIP: remove route implementation WIP: support custom method types WIP: extractor tests WIP: v5.0.x proposal over v4.4.0
267 lines
7.7 KiB
Go
267 lines
7.7 KiB
Go
// +build go1.15
|
|
|
|
package echo
|
|
|
|
/**
|
|
Since version 1.15 time.Time and time.Duration error message pattern has changed (values are wrapped now in \"\")
|
|
So pre 1.15 these tests fail with similar error:
|
|
|
|
expected: "code=400, message=failed to bind field value to Duration, internal=time: invalid duration \"nope\", field=param"
|
|
actual : "code=400, message=failed to bind field value to Duration, internal=time: invalid duration nope, field=param"
|
|
*/
|
|
|
|
import (
|
|
"errors"
|
|
"github.com/stretchr/testify/assert"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func createTestContext15(URL string, body io.Reader, pathParams map[string]string) Context {
|
|
e := New()
|
|
req := httptest.NewRequest(http.MethodGet, URL, body)
|
|
if body != nil {
|
|
req.Header.Set(HeaderContentType, MIMEApplicationJSON)
|
|
}
|
|
rec := httptest.NewRecorder()
|
|
c := e.NewContext(req, rec)
|
|
|
|
if len(pathParams) > 0 {
|
|
params := make(PathParams, 0)
|
|
for name, value := range pathParams {
|
|
params = append(params, PathParam{
|
|
Name: name,
|
|
Value: value,
|
|
})
|
|
}
|
|
cc := c.(EditableContext)
|
|
cc.SetPathParams(params)
|
|
}
|
|
|
|
return c
|
|
}
|
|
|
|
func TestValueBinder_TimeError(t *testing.T) {
|
|
var testCases = []struct {
|
|
name string
|
|
givenFailFast bool
|
|
givenBindErrors []error
|
|
whenURL string
|
|
whenMust bool
|
|
whenLayout string
|
|
expectValue time.Time
|
|
expectError string
|
|
}{
|
|
{
|
|
name: "nok, conversion fails, value is not changed",
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: time.Time{},
|
|
expectError: "code=400, message=failed to bind field value to Time, internal=parsing time \"nope\": extra text: \"nope\", field=param",
|
|
},
|
|
{
|
|
name: "nok (must), conversion fails, value is not changed",
|
|
whenMust: true,
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: time.Time{},
|
|
expectError: "code=400, message=failed to bind field value to Time, internal=parsing time \"nope\": extra text: \"nope\", field=param",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
c := createTestContext15(tc.whenURL, nil, nil)
|
|
b := QueryParamsBinder(c).FailFast(tc.givenFailFast)
|
|
if tc.givenFailFast {
|
|
b.errors = []error{errors.New("previous error")}
|
|
}
|
|
|
|
dest := time.Time{}
|
|
var err error
|
|
if tc.whenMust {
|
|
err = b.MustTime("param", &dest, tc.whenLayout).BindError()
|
|
} else {
|
|
err = b.Time("param", &dest, tc.whenLayout).BindError()
|
|
}
|
|
|
|
assert.Equal(t, tc.expectValue, dest)
|
|
if tc.expectError != "" {
|
|
assert.EqualError(t, err, tc.expectError)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValueBinder_TimesError(t *testing.T) {
|
|
var testCases = []struct {
|
|
name string
|
|
givenFailFast bool
|
|
givenBindErrors []error
|
|
whenURL string
|
|
whenMust bool
|
|
whenLayout string
|
|
expectValue []time.Time
|
|
expectError string
|
|
}{
|
|
{
|
|
name: "nok, fail fast without binding value",
|
|
givenFailFast: true,
|
|
whenURL: "/search?param=1¶m=100",
|
|
expectValue: []time.Time(nil),
|
|
expectError: "code=400, message=failed to bind field value to Time, internal=parsing time \"1\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"1\" as \"2006\", field=param",
|
|
},
|
|
{
|
|
name: "nok, conversion fails, value is not changed",
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: []time.Time(nil),
|
|
expectError: "code=400, message=failed to bind field value to Time, internal=parsing time \"nope\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"nope\" as \"2006\", field=param",
|
|
},
|
|
{
|
|
name: "nok (must), conversion fails, value is not changed",
|
|
whenMust: true,
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: []time.Time(nil),
|
|
expectError: "code=400, message=failed to bind field value to Time, internal=parsing time \"nope\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"nope\" as \"2006\", field=param",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
c := createTestContext15(tc.whenURL, nil, nil)
|
|
b := QueryParamsBinder(c).FailFast(tc.givenFailFast)
|
|
b.errors = tc.givenBindErrors
|
|
|
|
layout := time.RFC3339
|
|
if tc.whenLayout != "" {
|
|
layout = tc.whenLayout
|
|
}
|
|
|
|
var dest []time.Time
|
|
var err error
|
|
if tc.whenMust {
|
|
err = b.MustTimes("param", &dest, layout).BindError()
|
|
} else {
|
|
err = b.Times("param", &dest, layout).BindError()
|
|
}
|
|
|
|
assert.Equal(t, tc.expectValue, dest)
|
|
if tc.expectError != "" {
|
|
assert.EqualError(t, err, tc.expectError)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValueBinder_DurationError(t *testing.T) {
|
|
var testCases = []struct {
|
|
name string
|
|
givenFailFast bool
|
|
givenBindErrors []error
|
|
whenURL string
|
|
whenMust bool
|
|
expectValue time.Duration
|
|
expectError string
|
|
}{
|
|
{
|
|
name: "nok, conversion fails, value is not changed",
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: 0,
|
|
expectError: "code=400, message=failed to bind field value to Duration, internal=time: invalid duration \"nope\", field=param",
|
|
},
|
|
{
|
|
name: "nok (must), conversion fails, value is not changed",
|
|
whenMust: true,
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: 0,
|
|
expectError: "code=400, message=failed to bind field value to Duration, internal=time: invalid duration \"nope\", field=param",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
c := createTestContext15(tc.whenURL, nil, nil)
|
|
b := QueryParamsBinder(c).FailFast(tc.givenFailFast)
|
|
if tc.givenFailFast {
|
|
b.errors = []error{errors.New("previous error")}
|
|
}
|
|
|
|
var dest time.Duration
|
|
var err error
|
|
if tc.whenMust {
|
|
err = b.MustDuration("param", &dest).BindError()
|
|
} else {
|
|
err = b.Duration("param", &dest).BindError()
|
|
}
|
|
|
|
assert.Equal(t, tc.expectValue, dest)
|
|
if tc.expectError != "" {
|
|
assert.EqualError(t, err, tc.expectError)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValueBinder_DurationsError(t *testing.T) {
|
|
var testCases = []struct {
|
|
name string
|
|
givenFailFast bool
|
|
givenBindErrors []error
|
|
whenURL string
|
|
whenMust bool
|
|
expectValue []time.Duration
|
|
expectError string
|
|
}{
|
|
{
|
|
name: "nok, fail fast without binding value",
|
|
givenFailFast: true,
|
|
whenURL: "/search?param=1¶m=100",
|
|
expectValue: []time.Duration(nil),
|
|
expectError: "code=400, message=failed to bind field value to Duration, internal=time: missing unit in duration \"1\", field=param",
|
|
},
|
|
{
|
|
name: "nok, conversion fails, value is not changed",
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: []time.Duration(nil),
|
|
expectError: "code=400, message=failed to bind field value to Duration, internal=time: invalid duration \"nope\", field=param",
|
|
},
|
|
{
|
|
name: "nok (must), conversion fails, value is not changed",
|
|
whenMust: true,
|
|
whenURL: "/search?param=nope¶m=100",
|
|
expectValue: []time.Duration(nil),
|
|
expectError: "code=400, message=failed to bind field value to Duration, internal=time: invalid duration \"nope\", field=param",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
c := createTestContext15(tc.whenURL, nil, nil)
|
|
b := QueryParamsBinder(c).FailFast(tc.givenFailFast)
|
|
b.errors = tc.givenBindErrors
|
|
|
|
var dest []time.Duration
|
|
var err error
|
|
if tc.whenMust {
|
|
err = b.MustDurations("param", &dest).BindError()
|
|
} else {
|
|
err = b.Durations("param", &dest).BindError()
|
|
}
|
|
|
|
assert.Equal(t, tc.expectValue, dest)
|
|
if tc.expectError != "" {
|
|
assert.EqualError(t, err, tc.expectError)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|