go.sdls.io/sin@v0.0.9/pkg/sin/routergroup_test.go (about)

     1  // Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
     2  // Use of this source code is governed by a MIT style
     3  // license that can be found in the LICENSE file.
     4  
     5  package sin
     6  
     7  import (
     8  	"net/http"
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestRouterGroupBasic(t *testing.T) {
    15  	router := New()
    16  	group := router.Group("/hola", func(c *Context) {})
    17  	group.Use(func(c *Context) {})
    18  
    19  	assert.Len(t, group.Handlers, 2)
    20  	assert.Equal(t, "/hola", group.BasePath())
    21  	assert.Equal(t, router, group.engine)
    22  
    23  	group2 := group.Group("manu")
    24  	group2.Use(func(c *Context) {}, func(c *Context) {})
    25  
    26  	assert.Len(t, group2.Handlers, 4)
    27  	assert.Equal(t, "/hola/manu", group2.BasePath())
    28  	assert.Equal(t, router, group2.engine)
    29  }
    30  
    31  func TestRouterGroupBasicHandle(t *testing.T) {
    32  	performRequestInGroup(t, http.MethodGet)
    33  	performRequestInGroup(t, http.MethodPost)
    34  	performRequestInGroup(t, http.MethodPut)
    35  	performRequestInGroup(t, http.MethodPatch)
    36  	performRequestInGroup(t, http.MethodDelete)
    37  	performRequestInGroup(t, http.MethodHead)
    38  	performRequestInGroup(t, http.MethodOptions)
    39  }
    40  
    41  func performRequestInGroup(t *testing.T, method string) {
    42  	router := New()
    43  	v1 := router.Group("v1", func(c *Context) {})
    44  	assert.Equal(t, "/v1", v1.BasePath())
    45  
    46  	login := v1.Group("/login/", func(c *Context) {}, func(c *Context) {})
    47  	assert.Equal(t, "/v1/login/", login.BasePath())
    48  
    49  	handler := func(c *Context) {
    50  		c.String(http.StatusBadRequest, "the method was %s and index %d", c.Request.Method, c.index)
    51  	}
    52  
    53  	switch method {
    54  	case http.MethodGet:
    55  		v1.GET("/test", handler)
    56  		login.GET("/test", handler)
    57  	case http.MethodPost:
    58  		v1.POST("/test", handler)
    59  		login.POST("/test", handler)
    60  	case http.MethodPut:
    61  		v1.PUT("/test", handler)
    62  		login.PUT("/test", handler)
    63  	case http.MethodPatch:
    64  		v1.PATCH("/test", handler)
    65  		login.PATCH("/test", handler)
    66  	case http.MethodDelete:
    67  		v1.DELETE("/test", handler)
    68  		login.DELETE("/test", handler)
    69  	case http.MethodHead:
    70  		v1.HEAD("/test", handler)
    71  		login.HEAD("/test", handler)
    72  	case http.MethodOptions:
    73  		v1.OPTIONS("/test", handler)
    74  		login.OPTIONS("/test", handler)
    75  	default:
    76  		panic("unknown method")
    77  	}
    78  
    79  	w := performRequest(router, method, "/v1/login/test")
    80  	assert.Equal(t, http.StatusBadRequest, w.Code)
    81  	assert.Equal(t, "the method was "+method+" and index 3", w.Body.String())
    82  
    83  	w = performRequest(router, method, "/v1/test")
    84  	assert.Equal(t, http.StatusBadRequest, w.Code)
    85  	assert.Equal(t, "the method was "+method+" and index 1", w.Body.String())
    86  }
    87  
    88  func TestRouterGroupTooManyHandlers(t *testing.T) {
    89  	router := New()
    90  	handlers1 := make([]HandlerFunc, 40)
    91  	router.Use(handlers1...)
    92  
    93  	handlers2 := make([]HandlerFunc, 26)
    94  	assert.Panics(t, func() {
    95  		router.Use(handlers2...)
    96  	})
    97  	assert.Panics(t, func() {
    98  		router.GET("/", handlers2...)
    99  	})
   100  }
   101  
   102  func TestRouterGroupBadMethod(t *testing.T) {
   103  	router := New()
   104  	assert.Panics(t, func() {
   105  		router.Handle(http.MethodGet, "/")
   106  	})
   107  	assert.Panics(t, func() {
   108  		router.Handle(" GET", "/")
   109  	})
   110  	assert.Panics(t, func() {
   111  		router.Handle("GET ", "/")
   112  	})
   113  	assert.Panics(t, func() {
   114  		router.Handle("", "/")
   115  	})
   116  	assert.Panics(t, func() {
   117  		router.Handle("PO ST", "/")
   118  	})
   119  	assert.Panics(t, func() {
   120  		router.Handle("1GET", "/")
   121  	})
   122  	assert.Panics(t, func() {
   123  		router.Handle("PATCh", "/")
   124  	})
   125  }
   126  
   127  func TestRouterGroupPipeline(t *testing.T) {
   128  	router := New()
   129  	testRoutesInterface(t, router)
   130  
   131  	v1 := router.Group("/v1")
   132  	testRoutesInterface(t, v1)
   133  }
   134  
   135  func testRoutesInterface(t *testing.T, r IRoutes) {
   136  	handler := func(c *Context) {}
   137  	assert.Equal(t, r, r.Use(handler))
   138  
   139  	assert.Equal(t, r, r.Handle(http.MethodGet, "/handler", handler))
   140  	assert.Equal(t, r, r.Any("/any", handler))
   141  	assert.Equal(t, r, r.GET("/", handler))
   142  	assert.Equal(t, r, r.POST("/", handler))
   143  	assert.Equal(t, r, r.DELETE("/", handler))
   144  	assert.Equal(t, r, r.PATCH("/", handler))
   145  	assert.Equal(t, r, r.PUT("/", handler))
   146  	assert.Equal(t, r, r.OPTIONS("/", handler))
   147  	assert.Equal(t, r, r.HEAD("/", handler))
   148  }