package v4_rc
import (
"fmt"
"github.com/stretchr/testify/assert"
"net/http"
"reflect"
"testing"
)
type TestNode struct {
method string
path string
}
func TestRouter_AddRoute(t *testing.T) {
// step1. 构造路由森林
testRoutes := []TestNode{
{
method: http.MethodGet,
path: "/",
},
{
method: http.MethodGet,
path: "/user",
},
{
method: http.MethodGet,
path: "/user/home",
},
{
method: http.MethodGet,
path: "/order/detail",
},
{
method: http.MethodPost,
path: "/login",
},
{
method: http.MethodPost,
path: "/order/create",
},
}
targetRouter := newRouter()
mockHandleFunc := func(ctx *Context) {}
for _, testRoute := range testRoutes {
targetRouter.addRoute(testRoute.method, testRoute.path, mockHandleFunc)
}
// step2. 验证路由树
wantRouter := &router{
trees: map[string]*node{
http.MethodGet: &node{
path: "/",
children: map[string]*node{
"user": &node{
path: "user",
children: map[string]*node{
"home": &node{
path: "home",
children: nil,
HandleFunc: mockHandleFunc,
},
},
HandleFunc: mockHandleFunc,
},
"order": &node{
path: "order",
children: map[string]*node{
"detail": &node{
path: "detail",
children: nil,
HandleFunc: mockHandleFunc,
},
},
HandleFunc: nil,
},
},
HandleFunc: mockHandleFunc,
},
http.MethodPost: &node{
path: "/",
children: map[string]*node{
"login": &node{
path: "login",
children: nil,
HandleFunc: mockHandleFunc,
},
"order": &node{
path: "order",
children: map[string]*node{
"create": &node{
path: "create",
children: nil,
HandleFunc: mockHandleFunc,
},
},
HandleFunc: nil,
},
},
HandleFunc: nil,
},
},
}
msg, ok := wantRouter.equal(targetRouter)
assert.True(t, ok, msg)
}
func (r *router) equal(target *router) (msg string, ok bool) {
// step1. 比较路由森林中的路由树数量
wantLen := len(r.trees)
targetLen := len(target.trees)
if wantLen != targetLen {
msg = fmt.Sprintf("路由森林中的路由树数量不等, 期望路由树的数量为: %d, 目标路由树的数量为: %d", wantLen, targetLen)
return msg, false
}
// step2. 比对2个路由森林中的路由树HTTP动词是否相同
for method, tree := range r.trees {
dstTree, ok := target.trees[method]
if !ok {
msg = fmt.Sprintf("目标路由森林中不存在HTTP动词为: %s 的路由树", method)
return msg, false
}
// step3. 比对2个路由树中的结构是否相同
msg, ok = tree.equal(dstTree)
if !ok {
return msg, false
}
}
return "", true
}
func (n *node) equal(target *node) (msg string, ok bool) {
// step1. 目标节点为空 则必然不等
if target == nil {
msg = "目标节点为nil"
return msg, false
}
// step2. 比较节点的路径是否相同
if n.path != target.path {
msg = fmt.Sprintf("节点的路径不等, 期望节点的路径为: %s, 目标节点的路径为: %s", n.path, target.path)
return msg, false
}
// step3. 比较2个节点的子节点数量是否相同
if len(n.children) != len(target.children) {
msg = fmt.Sprintf("节点的子节点数量不等, 期望节点的子节点数量为: %d, 目标节点的子节点数量为: %d", len(n.children), len(target.children))
return msg, false
}
// step4. 比较2个节点的处理函数是否相同
wantHandler := reflect.ValueOf(n.HandleFunc)
targetHandler := reflect.ValueOf(target.HandleFunc)
if wantHandler != targetHandler {
msg = fmt.Sprintf("节点的处理函数不等, 期望节点 %s 的处理函数为: %v, 目标节点 %s 的处理函数为: %v", n.path, wantHandler, target.path, targetHandler)
return msg, false
}
// step5. 比较2个节点的子节点是否相同
for path, child := range n.children {
// step5.1 比对2个节点的子节点的路径是否相同
dstChild, exist := target.children[path]
if !exist {
msg = fmt.Sprintf("目标节点中不存在路径为: %s 的子节点", path)
return msg, false
}
// step5.2 对路径相同的子节点递归比对
msg, equal := child.equal(dstChild)
if !equal {
return msg, false
}
}
return "", true
}
func TestRouter_Illegal_Path(t *testing.T) {
r := newRouter()
mockHandle := func(ctx *Context) {}
nilPathFunc := func() { r.addRoute(http.MethodGet, "", mockHandle) }
assert.Panicsf(t, nilPathFunc, "web: 路由不能为空字符串")
}
