func TestContextError(t *testing.T) { c, _, _ := createTestContext() assert.Empty(t, c.Errors) c.Error(errors.New("first error")) assert.Len(t, c.Errors, 1) assert.Equal(t, c.Errors.String(), "Error #01: first error\n") c.Error(&Error{ Err: errors.New("second error"), Meta: "some data 2", Type: ErrorTypePublic, }) assert.Len(t, c.Errors, 2) assert.Equal(t, c.Errors[0].Err, errors.New("first error")) assert.Nil(t, c.Errors[0].Meta) assert.Equal(t, c.Errors[0].Type, ErrorTypePrivate) assert.Equal(t, c.Errors[1].Err, errors.New("second error")) assert.Equal(t, c.Errors[1].Meta, "some data 2") assert.Equal(t, c.Errors[1].Type, ErrorTypePublic) assert.Equal(t, c.Errors.Last(), c.Errors[1]) }
func TestRouterGroupBasic(t *testing.T) { router := New() group := router.Group("/hola", func(c *Context) {}) group.Use(func(c *Context) {}) assert.Len(t, group.Handlers, 2) assert.Equal(t, group.BasePath, "/hola") assert.Equal(t, group.engine, router) group2 := group.Group("manu") group2.Use(func(c *Context) {}, func(c *Context) {}) assert.Len(t, group2.Handlers, 4) assert.Equal(t, group2.BasePath, "/hola/manu") assert.Equal(t, group2.engine, router) }
func assertFilter(t *testing.T, filter, field, op, val string) { arr, err := _parseSearchQuery(filter) assert.NoError(t, err) assert.NotNil(t, arr) assert.Len(t, arr, 1) assert.Equal(t, arr[0], &ep.FilterData{field, op, val}) }
// Test that the system doesn't fail under high pressure. func TestSubFlooding(t *testing.T) { NUM_SUBS := 100 // Keep the reaper out of this. reaperThreshold = 10000 * time.Millisecond reaperTimeout = 10000 * time.Millisecond // Crank it up. Now pressure is 10 times higher on each sub. mockInterval = 1 * time.Millisecond mee := newMockEventEmitter() eSubs := NewEventSubscriptions(mee) doneChan := make(chan error) go func() { for i := 0; i < NUM_SUBS; i++ { time.Sleep(1 * time.Millisecond) go func() { id, err := eSubs.add("WeirdEvent") if err != nil { doneChan <- err return } if len(id) != 64 { doneChan <- fmt.Errorf("Id not of length 64") return } _, err2 := hex.DecodeString(id) if err2 != nil { doneChan <- err2 } time.Sleep(1000 * time.Millisecond) err3 := eSubs.remove(id) if err3 != nil { doneChan <- err3 } doneChan <- nil }() } }() k := 0 for k < NUM_SUBS { err := <-doneChan assert.NoError(t, err) k++ } assert.Len(t, mee.subs, 0) assert.Len(t, eSubs.subs, 0) t.Logf("Added %d subs that all received 1000 events each. They were all closed down by unsubscribing.", NUM_SUBS) }
func TestAddRoute(t *testing.T) { router := New() router.addRoute("GET", "/", HandlersChain{func(_ *Context) {}}) assert.Len(t, router.trees, 1) assert.NotNil(t, router.trees.get("GET")) assert.Nil(t, router.trees.get("POST")) router.addRoute("POST", "/", HandlersChain{func(_ *Context) {}}) assert.Len(t, router.trees, 2) assert.NotNil(t, router.trees.get("GET")) assert.NotNil(t, router.trees.get("POST")) router.addRoute("POST", "/post", HandlersChain{func(_ *Context) {}}) assert.Len(t, router.trees, 2) }
func TestParseAccept(t *testing.T) { parts := parseAccept("text/html , application/xhtml+xml,application/xml;q=0.9, */* ;q=0.8") assert.Len(t, parts, 4) assert.Equal(t, parts[0], "text/html") assert.Equal(t, parts[1], "application/xhtml+xml") assert.Equal(t, parts[2], "application/xml") assert.Equal(t, parts[3], "*/*") }
func assertRangeFilter(t *testing.T, min, max, res0, res1 string) { arr, err := _parseSearchQuery("test:" + min + ".." + max) assert.NoError(t, err) assert.NotNil(t, arr) assert.Len(t, arr, 2) assert.Equal(t, arr[0], &ep.FilterData{"test", ">=", res0}) assert.Equal(t, arr[1], &ep.FilterData{"test", "<=", res1}) }
// Test that event subscriptions can be added manually and then automatically reaped. func TestSubReaping(t *testing.T) { runtime.GOMAXPROCS(runtime.NumCPU()) NUM_SUBS := 100 reaperThreshold = 200 * time.Millisecond reaperTimeout = 100 * time.Millisecond mee := newMockEventEmitter() eSubs := NewEventSubscriptions(mee) doneChan := make(chan error) go func() { for i := 0; i < NUM_SUBS; i++ { time.Sleep(2 * time.Millisecond) go func() { id, err := eSubs.add("WeirdEvent") if err != nil { doneChan <- err return } if len(id) != 64 { doneChan <- fmt.Errorf("Id not of length 64") return } _, err2 := hex.DecodeString(id) if err2 != nil { doneChan <- err2 } doneChan <- nil }() } }() k := 0 for k < NUM_SUBS { err := <-doneChan assert.NoError(t, err) k++ } time.Sleep(1100 * time.Millisecond) assert.Len(t, mee.subs, 0) assert.Len(t, eSubs.subs, 0) t.Logf("Added %d subs that were all automatically reaped.", NUM_SUBS) }
func TestNoRouteWithoutGlobalHandlers(t *testing.T) { var middleware0 HandlerFunc = func(c *Context) {} var middleware1 HandlerFunc = func(c *Context) {} router := New() router.NoRoute(middleware0) assert.Nil(t, router.Handlers) assert.Len(t, router.noRoute, 1) assert.Len(t, router.allNoRoute, 1) compareFunc(t, router.noRoute[0], middleware0) compareFunc(t, router.allNoRoute[0], middleware0) router.NoRoute(middleware1, middleware0) assert.Len(t, router.noRoute, 2) assert.Len(t, router.allNoRoute, 2) compareFunc(t, router.noRoute[0], middleware1) compareFunc(t, router.allNoRoute[0], middleware1) compareFunc(t, router.noRoute[1], middleware0) compareFunc(t, router.allNoRoute[1], middleware0) }
func TestNoMethodWithoutGlobalHandlers(t *testing.T) { var middleware0 HandlerFunc = func(c *Context) {} var middleware1 HandlerFunc = func(c *Context) {} router := New() router.NoMethod(middleware0) assert.Empty(t, router.Handlers) assert.Len(t, router.noMethod, 1) assert.Len(t, router.allNoMethod, 1) compareFunc(t, router.noMethod[0], middleware0) compareFunc(t, router.allNoMethod[0], middleware0) router.NoMethod(middleware1, middleware0) assert.Len(t, router.noMethod, 2) assert.Len(t, router.allNoMethod, 2) compareFunc(t, router.noMethod[0], middleware1) compareFunc(t, router.allNoMethod[0], middleware1) compareFunc(t, router.noMethod[1], middleware0) compareFunc(t, router.allNoMethod[1], middleware0) }
func TestContextReset(t *testing.T) { router := New() c := router.allocateContext() assert.Equal(t, c.engine, router) c.index = 2 c.Writer = &responseWriter{ResponseWriter: httptest.NewRecorder()} c.Params = Params{Param{}} c.Error(errors.New("test")) c.Set("foo", "bar") c.reset() assert.False(t, c.IsAborted()) assert.Nil(t, c.Keys) assert.Nil(t, c.Accepted) assert.Len(t, c.Errors, 0) assert.Empty(t, c.Errors.Errors()) assert.Empty(t, c.Errors.ByType(ErrorTypeAny)) assert.Len(t, c.Params, 0) assert.EqualValues(t, c.index, -1) assert.Equal(t, c.Writer.(*responseWriter), &c.writermem) }
func TestCombined(t *testing.T) { q := "balance:>=5 sequence:<8" arr, err := _parseSearchQuery(q) assert.NoError(t, err) assert.Len(t, arr, 2) f0 := arr[0] assert.Equal(t, f0.Field, "balance") assert.Equal(t, f0.Op, ">=") assert.Equal(t, f0.Value, "5") f1 := arr[1] assert.Equal(t, f1.Field, "sequence") assert.Equal(t, f1.Op, "<") assert.Equal(t, f1.Value, "8") }
func TestListOfRoutes(t *testing.T) { router := New() router.GET("/favicon.ico", handler_test1) router.GET("/", handler_test1) group := router.Group("/users") { group.GET("/", handler_test2) group.GET("/:id", handler_test1) group.POST("/:id", handler_test2) } router.Static("/static", ".") list := router.Routes() assert.Len(t, list, 7) assert.Contains(t, list, RouteInfo{ Method: "GET", Path: "/favicon.ico", Handler: "github.com/gin-gonic/gin.handler_test1", }) assert.Contains(t, list, RouteInfo{ Method: "GET", Path: "/", Handler: "github.com/gin-gonic/gin.handler_test1", }) assert.Contains(t, list, RouteInfo{ Method: "GET", Path: "/users/", Handler: "github.com/gin-gonic/gin.handler_test2", }) assert.Contains(t, list, RouteInfo{ Method: "GET", Path: "/users/:id", Handler: "github.com/gin-gonic/gin.handler_test1", }) assert.Contains(t, list, RouteInfo{ Method: "POST", Path: "/users/:id", Handler: "github.com/gin-gonic/gin.handler_test2", }) }
func TestBasicAuth(t *testing.T) { pairs := processAccounts(Accounts{ "admin": "password", "foo": "bar", "bar": "foo", }) assert.Len(t, pairs, 3) assert.Contains(t, pairs, authPair{ User: "******", Value: "Basic YmFyOmZvbw==", }) assert.Contains(t, pairs, authPair{ User: "******", Value: "Basic Zm9vOmJhcg==", }) assert.Contains(t, pairs, authPair{ User: "******", Value: "Basic YWRtaW46cGFzc3dvcmQ=", }) }
// Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. // // require.Len(t, mySlice, 3, "The size of slice is not 3") func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) { if !assert.Len(t, object, length, msgAndArgs...) { t.FailNow() } }
func TestCreateDefaultRouter(t *testing.T) { router := Default() assert.Len(t, router.Handlers, 2) }