827 lines
21 KiB
V
827 lines
21 KiB
V
import hono
|
|
import net.http
|
|
|
|
fn main() {
|
|
println('=== 高级动态路由测试用例 ===')
|
|
|
|
// 测试1: 复杂嵌套参数路由
|
|
test_complex_nested_routes()
|
|
|
|
// 测试2: RESTful API 路由模式
|
|
test_restful_api_patterns()
|
|
|
|
// 测试3: 版本化API路由
|
|
test_versioned_api_routes()
|
|
|
|
// 测试4: 文件路径路由
|
|
test_file_path_routes()
|
|
|
|
// 测试5: 多语言路由
|
|
test_multilingual_routes()
|
|
|
|
// 测试6: 子域名路由模拟
|
|
test_subdomain_simulation()
|
|
|
|
// 测试7: 动态中间件路由
|
|
test_dynamic_middleware_routes()
|
|
|
|
println('✅ 高级动态路由测试完成')
|
|
}
|
|
|
|
fn test_complex_nested_routes() {
|
|
println('\n📊 复杂嵌套参数路由测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// 复杂嵌套路由定义
|
|
complex_routes := [
|
|
// 电商平台路由
|
|
'/shop/:region/:city/stores/:store_id/products/:category/:product_id',
|
|
'/shop/:region/:city/stores/:store_id/orders/:order_id/items/:item_id',
|
|
'/shop/:region/:city/stores/:store_id/reviews/:review_id/replies/:reply_id',
|
|
|
|
// 社交媒体路由
|
|
'/social/:platform/users/:user_id/posts/:post_id/comments/:comment_id/likes',
|
|
'/social/:platform/groups/:group_id/events/:event_id/attendees/:user_id',
|
|
'/social/:platform/pages/:page_id/posts/:post_id/shares/:share_id',
|
|
|
|
// 企业管理路由
|
|
'/enterprise/:org_id/departments/:dept_id/teams/:team_id/members/:member_id',
|
|
'/enterprise/:org_id/projects/:project_id/tasks/:task_id/subtasks/:subtask_id',
|
|
'/enterprise/:org_id/budgets/:budget_id/categories/:category_id/items/:item_id'
|
|
]
|
|
|
|
// 添加路由
|
|
for route in complex_routes {
|
|
app.get(route, fn (mut c hono.Context) http.Response {
|
|
return c.text('Complex route response')
|
|
})
|
|
}
|
|
|
|
// 测试路径
|
|
test_cases := [
|
|
{
|
|
'route': '/shop/:region/:city/stores/:store_id/products/:category/:product_id'
|
|
'path': '/shop/asia/beijing/stores/store123/products/electronics/phone456'
|
|
'expected_params': 'region:asia,city:beijing,store_id:store123,category:electronics,product_id:phone456'
|
|
},
|
|
{
|
|
'route': '/social/:platform/users/:user_id/posts/:post_id/comments/:comment_id/likes'
|
|
'path': '/social/twitter/users/user789/posts/post101/comments/comment202/likes'
|
|
'expected_params': 'platform:twitter,user_id:user789,post_id:post101,comment_id:comment202'
|
|
},
|
|
{
|
|
'route': '/enterprise/:org_id/departments/:dept_id/teams/:team_id/members/:member_id'
|
|
'path': '/enterprise/org999/departments/dept888/teams/team777/members/member666'
|
|
'expected_params': 'org_id:org999,dept_id:dept888,team_id:team777,member_id:member666'
|
|
}
|
|
]
|
|
|
|
mut success_count := 0
|
|
for test_case in test_cases {
|
|
if match_result := app.fast_router.match_route('GET', test_case['path']) {
|
|
// 验证参数提取
|
|
mut param_check_passed := true
|
|
expected_params := test_case['expected_params'].split(',')
|
|
|
|
for expected_param in expected_params {
|
|
parts := expected_param.split(':')
|
|
if parts.len == 2 {
|
|
param_name := parts[0].trim_space()
|
|
expected_value := parts[1].trim_space()
|
|
|
|
if actual_value := match_result.params[param_name] {
|
|
if actual_value != expected_value {
|
|
param_check_passed = false
|
|
break
|
|
}
|
|
} else {
|
|
param_check_passed = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if param_check_passed {
|
|
success_count++
|
|
println(' ✅ ${test_case['path']} - 参数提取正确')
|
|
} else {
|
|
println(' ❌ ${test_case['path']} - 参数提取错误')
|
|
}
|
|
} else {
|
|
println(' ❌ ${test_case['path']} - 路由匹配失败')
|
|
}
|
|
}
|
|
|
|
println(' 复杂嵌套路由测试: ${success_count}/${test_cases.len} 通过')
|
|
}
|
|
|
|
fn test_restful_api_patterns() {
|
|
println('\n📊 RESTful API 路由模式测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// RESTful 资源路由
|
|
restful_patterns := [
|
|
// 用户资源
|
|
'/api/users', // GET: 列表, POST: 创建
|
|
'/api/users/:id', // GET: 详情, PUT: 更新, DELETE: 删除
|
|
'/api/users/:id/profile', // GET: 用户资料
|
|
'/api/users/:id/settings', // GET/PUT: 用户设置
|
|
|
|
// 嵌套资源
|
|
'/api/users/:user_id/posts', // GET: 用户文章列表, POST: 创建文章
|
|
'/api/users/:user_id/posts/:post_id', // GET: 文章详情, PUT: 更新, DELETE: 删除
|
|
'/api/users/:user_id/posts/:post_id/comments', // GET: 评论列表, POST: 添加评论
|
|
'/api/users/:user_id/posts/:post_id/comments/:comment_id', // GET/PUT/DELETE: 评论操作
|
|
|
|
// 关系资源
|
|
'/api/users/:user_id/followers', // GET: 关注者列表
|
|
'/api/users/:user_id/following', // GET: 关注列表
|
|
'/api/users/:user_id/follow/:target_id', // POST: 关注, DELETE: 取消关注
|
|
|
|
// 搜索和过滤
|
|
'/api/search/users/:query', // GET: 搜索用户
|
|
'/api/search/posts/:query', // GET: 搜索文章
|
|
'/api/filter/posts/:category/:tag', // GET: 按分类和标签过滤
|
|
]
|
|
|
|
// 添加所有RESTful路由
|
|
for pattern in restful_patterns {
|
|
// 模拟不同HTTP方法
|
|
app.get(pattern, fn (mut c hono.Context) http.Response {
|
|
return c.text('GET response')
|
|
})
|
|
app.post(pattern, fn (mut c hono.Context) http.Response {
|
|
return c.text('POST response')
|
|
})
|
|
app.put(pattern, fn (mut c hono.Context) http.Response {
|
|
return c.text('PUT response')
|
|
})
|
|
app.delete(pattern, fn (mut c hono.Context) http.Response {
|
|
return c.text('DELETE response')
|
|
})
|
|
}
|
|
|
|
// 测试RESTful操作
|
|
restful_tests := [
|
|
{
|
|
'method': 'GET'
|
|
'path': '/api/users/123'
|
|
'description': '获取用户详情'
|
|
},
|
|
{
|
|
'method': 'POST'
|
|
'path': '/api/users/123/posts'
|
|
'description': '创建用户文章'
|
|
},
|
|
{
|
|
'method': 'PUT'
|
|
'path': '/api/users/123/posts/456'
|
|
'description': '更新文章'
|
|
},
|
|
{
|
|
'method': 'DELETE'
|
|
'path': '/api/users/123/posts/456/comments/789'
|
|
'description': '删除评论'
|
|
},
|
|
{
|
|
'method': 'GET'
|
|
'path': '/api/search/users/john'
|
|
'description': '搜索用户'
|
|
},
|
|
{
|
|
'method': 'GET'
|
|
'path': '/api/filter/posts/tech/javascript'
|
|
'description': '过滤文章'
|
|
}
|
|
]
|
|
|
|
mut restful_success := 0
|
|
for test in restful_tests {
|
|
if _ := app.fast_router.match_route(test['method'], test['path']) {
|
|
restful_success++
|
|
println(' ✅ ${test['method']} ${test['path']} - ${test['description']}')
|
|
} else {
|
|
println(' ❌ ${test['method']} ${test['path']} - ${test['description']}')
|
|
}
|
|
}
|
|
|
|
println(' RESTful API测试: ${restful_success}/${restful_tests.len} 通过')
|
|
}
|
|
|
|
fn test_versioned_api_routes() {
|
|
println('\n📊 版本化API路由测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// 版本化API路由
|
|
versioned_routes := [
|
|
// 版本1 API
|
|
'/api/v1/users/:id',
|
|
'/api/v1/posts/:id',
|
|
'/api/v1/auth/login',
|
|
|
|
// 版本2 API (向后兼容)
|
|
'/api/v2/users/:id',
|
|
'/api/v2/users/:id/profile',
|
|
'/api/v2/posts/:id',
|
|
'/api/v2/posts/:id/analytics',
|
|
'/api/v2/auth/oauth/:provider',
|
|
|
|
// 版本3 API (最新)
|
|
'/api/v3/users/:id',
|
|
'/api/v3/users/:id/preferences',
|
|
'/api/v3/posts/:id',
|
|
'/api/v3/posts/:id/engagement',
|
|
'/api/v3/auth/sso/:provider/:tenant',
|
|
|
|
// 通用版本路由
|
|
'/api/:version/health',
|
|
'/api/:version/status',
|
|
'/api/:version/metrics/:metric_type'
|
|
]
|
|
|
|
for route in versioned_routes {
|
|
app.get(route, fn (mut c hono.Context) http.Response {
|
|
return c.text('Versioned API response')
|
|
})
|
|
}
|
|
|
|
// 版本兼容性测试
|
|
version_tests := [
|
|
{
|
|
'path': '/api/v1/users/123'
|
|
'expected_version': 'v1'
|
|
},
|
|
{
|
|
'path': '/api/v2/users/456/profile'
|
|
'expected_version': 'v2'
|
|
},
|
|
{
|
|
'path': '/api/v3/auth/sso/google/tenant789'
|
|
'expected_version': 'v3'
|
|
},
|
|
{
|
|
'path': '/api/v2/health'
|
|
'expected_version': 'v2'
|
|
},
|
|
{
|
|
'path': '/api/v3/metrics/performance'
|
|
'expected_version': 'v3'
|
|
}
|
|
]
|
|
|
|
mut version_success := 0
|
|
for test in version_tests {
|
|
if match_result := app.fast_router.match_route('GET', test['path']) {
|
|
// 检查版本参数
|
|
if version := match_result.params['version'] {
|
|
if version == test['expected_version'] {
|
|
version_success++
|
|
println(' ✅ ${test['path']} - 版本${version}')
|
|
} else {
|
|
println(' ❌ ${test['path']} - 版本不匹配: 期望${test['expected_version']}, 实际${version}')
|
|
}
|
|
} else {
|
|
// 固定版本路由
|
|
if test['path'].contains(test['expected_version']) {
|
|
version_success++
|
|
println(' ✅ ${test['path']} - 固定版本${test['expected_version']}')
|
|
}
|
|
}
|
|
} else {
|
|
println(' ❌ ${test['path']} - 路由匹配失败')
|
|
}
|
|
}
|
|
|
|
println(' 版本化API测试: ${version_success}/${version_tests.len} 通过')
|
|
}
|
|
|
|
fn test_file_path_routes() {
|
|
println('\n📊 文件路径路由测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// 文件系统路由
|
|
file_routes := [
|
|
// 基础文件路由
|
|
'/files/:filename',
|
|
'/files/:category/:filename',
|
|
'/files/:year/:month/:filename',
|
|
'/files/:year/:month/:day/:filename',
|
|
|
|
// 用户文件路由
|
|
'/users/:user_id/files/:filename',
|
|
'/users/:user_id/files/:folder/:filename',
|
|
'/users/:user_id/files/:folder/:subfolder/:filename',
|
|
|
|
// 项目文件路由
|
|
'/projects/:project_id/files/:path/:filename',
|
|
'/projects/:project_id/versions/:version/files/:filename',
|
|
'/projects/:project_id/branches/:branch/files/:path/:filename',
|
|
|
|
// 媒体文件路由
|
|
'/media/:type/:resolution/:filename',
|
|
'/media/:type/:year/:month/:day/:filename',
|
|
'/media/thumbnails/:size/:filename',
|
|
|
|
// 文档路由
|
|
'/docs/:language/:category/:filename',
|
|
'/docs/:version/:language/:section/:filename'
|
|
]
|
|
|
|
for route in file_routes {
|
|
app.get(route, fn (mut c hono.Context) http.Response {
|
|
return c.text('File response')
|
|
})
|
|
}
|
|
|
|
// 文件路径测试用例
|
|
file_tests := [
|
|
{
|
|
'path': '/files/document.pdf'
|
|
'expected_params': 'filename:document.pdf'
|
|
},
|
|
{
|
|
'path': '/files/images/photo.jpg'
|
|
'expected_params': 'category:images,filename:photo.jpg'
|
|
},
|
|
{
|
|
'path': '/files/2023/12/report.xlsx'
|
|
'expected_params': 'year:2023,month:12,filename:report.xlsx'
|
|
},
|
|
{
|
|
'path': '/users/user123/files/documents/contract.pdf'
|
|
'expected_params': 'user_id:user123,folder:documents,filename:contract.pdf'
|
|
},
|
|
{
|
|
'path': '/projects/proj456/versions/v1.2.3/files/readme.md'
|
|
'expected_params': 'project_id:proj456,version:v1.2.3,filename:readme.md'
|
|
},
|
|
{
|
|
'path': '/media/video/1080p/movie.mp4'
|
|
'expected_params': 'type:video,resolution:1080p,filename:movie.mp4'
|
|
},
|
|
{
|
|
'path': '/docs/en/api/authentication.md'
|
|
'expected_params': 'language:en,category:api,filename:authentication.md'
|
|
}
|
|
]
|
|
|
|
mut file_success := 0
|
|
for test in file_tests {
|
|
if match_result := app.fast_router.match_route('GET', test['path']) {
|
|
mut params_correct := true
|
|
expected_params := test['expected_params'].split(',')
|
|
|
|
for expected_param in expected_params {
|
|
parts := expected_param.split(':')
|
|
if parts.len == 2 {
|
|
param_name := parts[0]
|
|
expected_value := parts[1]
|
|
|
|
if actual_value := match_result.params[param_name] {
|
|
if actual_value != expected_value {
|
|
params_correct = false
|
|
break
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if params_correct {
|
|
file_success++
|
|
println(' ✅ ${test['path']} - 参数正确')
|
|
} else {
|
|
println(' ❌ ${test['path']} - 参数错误')
|
|
}
|
|
} else {
|
|
println(' ❌ ${test['path']} - 路由匹配失败')
|
|
}
|
|
}
|
|
|
|
println(' 文件路径路由测试: ${file_success}/${file_tests.len} 通过')
|
|
}
|
|
|
|
fn test_multilingual_routes() {
|
|
println('\n📊 多语言路由测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// 多语言路由
|
|
multilingual_routes := [
|
|
// 基础多语言路由
|
|
'/:lang/home',
|
|
'/:lang/about',
|
|
'/:lang/contact',
|
|
|
|
// 多语言内容路由
|
|
'/:lang/articles/:id',
|
|
'/:lang/articles/:category/:slug',
|
|
'/:lang/products/:id',
|
|
'/:lang/products/:category/:product_id',
|
|
|
|
// 多语言用户路由
|
|
'/:lang/users/:id/profile',
|
|
'/:lang/users/:id/settings',
|
|
'/:lang/auth/login',
|
|
'/:lang/auth/register',
|
|
|
|
// 多语言API路由
|
|
'/api/:lang/search/:query',
|
|
'/api/:lang/translate/:from/:to/:text',
|
|
|
|
// 地区化路由
|
|
'/:country/:lang/stores',
|
|
'/:country/:lang/stores/:store_id',
|
|
'/:country/:lang/checkout/:step'
|
|
]
|
|
|
|
for route in multilingual_routes {
|
|
app.get(route, fn (mut c hono.Context) http.Response {
|
|
return c.text('Multilingual response')
|
|
})
|
|
}
|
|
|
|
// 多语言测试用例
|
|
multilingual_tests := [
|
|
{
|
|
'path': '/en/home'
|
|
'expected_lang': 'en'
|
|
},
|
|
{
|
|
'path': '/zh/articles/tech/ai-revolution'
|
|
'expected_lang': 'zh'
|
|
'expected_category': 'tech'
|
|
'expected_slug': 'ai-revolution'
|
|
},
|
|
{
|
|
'path': '/fr/users/123/profile'
|
|
'expected_lang': 'fr'
|
|
'expected_id': '123'
|
|
},
|
|
{
|
|
'path': '/api/es/search/machine learning'
|
|
'expected_lang': 'es'
|
|
'expected_query': 'machine learning'
|
|
},
|
|
{
|
|
'path': '/us/en/stores/store456'
|
|
'expected_country': 'us'
|
|
'expected_lang': 'en'
|
|
'expected_store_id': 'store456'
|
|
},
|
|
{
|
|
'path': '/jp/ja/checkout/payment'
|
|
'expected_country': 'jp'
|
|
'expected_lang': 'ja'
|
|
'expected_step': 'payment'
|
|
}
|
|
]
|
|
|
|
mut multilingual_success := 0
|
|
for test in multilingual_tests {
|
|
if match_result := app.fast_router.match_route('GET', test['path']) {
|
|
mut params_correct := true
|
|
|
|
// 检查语言参数
|
|
if expected_lang := test['expected_lang'] {
|
|
if actual_lang := match_result.params['lang'] {
|
|
if actual_lang != expected_lang {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
// 检查其他参数
|
|
test_params := ['expected_category', 'expected_slug', 'expected_id', 'expected_query', 'expected_country', 'expected_store_id', 'expected_step']
|
|
param_names := ['category', 'slug', 'id', 'query', 'country', 'store_id', 'step']
|
|
|
|
for i, test_param in test_params {
|
|
if expected_value := test[test_param] {
|
|
param_name := param_names[i]
|
|
if actual_value := match_result.params[param_name] {
|
|
if actual_value != expected_value {
|
|
params_correct = false
|
|
break
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if params_correct {
|
|
multilingual_success++
|
|
println(' ✅ ${test['path']} - 多语言参数正确')
|
|
} else {
|
|
println(' ❌ ${test['path']} - 多语言参数错误')
|
|
}
|
|
} else {
|
|
println(' ❌ ${test['path']} - 路由匹配失败')
|
|
}
|
|
}
|
|
|
|
println(' 多语言路由测试: ${multilingual_success}/${multilingual_tests.len} 通过')
|
|
}
|
|
|
|
fn test_subdomain_simulation() {
|
|
println('\n📊 子域名路由模拟测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// 模拟子域名路由 (通过路径前缀)
|
|
subdomain_routes := [
|
|
// API子域名
|
|
'/api.example.com/v1/users/:id',
|
|
'/api.example.com/v1/posts/:id',
|
|
'/api.example.com/health',
|
|
|
|
// 管理子域名
|
|
'/admin.example.com/dashboard',
|
|
'/admin.example.com/users/:id',
|
|
'/admin.example.com/settings/:section',
|
|
|
|
// 用户子域名
|
|
'/:username.example.com/profile',
|
|
'/:username.example.com/posts',
|
|
'/:username.example.com/posts/:post_id',
|
|
|
|
// 多租户子域名
|
|
'/:tenant.app.com/dashboard',
|
|
'/:tenant.app.com/users/:user_id',
|
|
'/:tenant.app.com/projects/:project_id',
|
|
|
|
// 地区子域名
|
|
'/:region.shop.com/products',
|
|
'/:region.shop.com/products/:category',
|
|
'/:region.shop.com/stores/:store_id'
|
|
]
|
|
|
|
for route in subdomain_routes {
|
|
app.get(route, fn (mut c hono.Context) http.Response {
|
|
return c.text('Subdomain response')
|
|
})
|
|
}
|
|
|
|
// 子域名测试用例
|
|
subdomain_tests := [
|
|
{
|
|
'path': '/api.example.com/v1/users/123'
|
|
'description': 'API子域名用户接口'
|
|
},
|
|
{
|
|
'path': '/admin.example.com/users/456'
|
|
'description': '管理子域名用户管理'
|
|
'expected_id': '456'
|
|
},
|
|
{
|
|
'path': '/john.example.com/posts/789'
|
|
'description': '用户子域名文章'
|
|
'expected_username': 'john'
|
|
'expected_post_id': '789'
|
|
},
|
|
{
|
|
'path': '/company1.app.com/projects/proj123'
|
|
'description': '多租户项目管理'
|
|
'expected_tenant': 'company1'
|
|
'expected_project_id': 'proj123'
|
|
},
|
|
{
|
|
'path': '/us.shop.com/products/electronics'
|
|
'description': '地区商店产品'
|
|
'expected_region': 'us'
|
|
'expected_category': 'electronics'
|
|
}
|
|
]
|
|
|
|
mut subdomain_success := 0
|
|
for test in subdomain_tests {
|
|
if match_result := app.fast_router.match_route('GET', test['path']) {
|
|
mut params_correct := true
|
|
|
|
// 检查参数
|
|
if expected_id := test['expected_id'] {
|
|
if actual_id := match_result.params['id'] {
|
|
if actual_id != expected_id {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_username := test['expected_username'] {
|
|
if actual_username := match_result.params['username'] {
|
|
if actual_username != expected_username {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_post_id := test['expected_post_id'] {
|
|
if actual_post_id := match_result.params['post_id'] {
|
|
if actual_post_id != expected_post_id {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_tenant := test['expected_tenant'] {
|
|
if actual_tenant := match_result.params['tenant'] {
|
|
if actual_tenant != expected_tenant {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_project_id := test['expected_project_id'] {
|
|
if actual_project_id := match_result.params['project_id'] {
|
|
if actual_project_id != expected_project_id {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_region := test['expected_region'] {
|
|
if actual_region := match_result.params['region'] {
|
|
if actual_region != expected_region {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_category := test['expected_category'] {
|
|
if actual_category := match_result.params['category'] {
|
|
if actual_category != expected_category {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if params_correct {
|
|
subdomain_success++
|
|
println(' ✅ ${test['path']} - ${test['description']}')
|
|
} else {
|
|
println(' ❌ ${test['path']} - ${test['description']} (参数错误)')
|
|
}
|
|
} else {
|
|
println(' ❌ ${test['path']} - ${test['description']} (匹配失败)')
|
|
}
|
|
}
|
|
|
|
println(' 子域名路由测试: ${subdomain_success}/${subdomain_tests.len} 通过')
|
|
}
|
|
|
|
fn test_dynamic_middleware_routes() {
|
|
println('\n📊 动态中间件路由测试...')
|
|
|
|
mut app := hono.Hono.new()
|
|
|
|
// 需要不同中间件的路由
|
|
middleware_routes := [
|
|
// 需要认证的路由
|
|
'/auth/profile/:id',
|
|
'/auth/settings/:section',
|
|
'/auth/admin/:action',
|
|
|
|
// 需要权限检查的路由
|
|
'/protected/users/:id/edit',
|
|
'/protected/posts/:id/delete',
|
|
'/protected/admin/:resource/:action',
|
|
|
|
// 需要限流的路由
|
|
'/rate-limited/api/:endpoint',
|
|
'/rate-limited/upload/:type',
|
|
'/rate-limited/search/:query',
|
|
|
|
// 需要缓存的路由
|
|
'/cached/articles/:id',
|
|
'/cached/products/:category/:id',
|
|
'/cached/static/:resource',
|
|
|
|
// 需要日志记录的路由
|
|
'/logged/transactions/:id',
|
|
'/logged/audit/:action/:resource',
|
|
'/logged/security/:event/:details'
|
|
]
|
|
|
|
for route in middleware_routes {
|
|
app.get(route, fn (mut c hono.Context) http.Response {
|
|
return c.text('Middleware route response')
|
|
})
|
|
}
|
|
|
|
// 中间件路由测试
|
|
middleware_tests := [
|
|
{
|
|
'path': '/auth/profile/user123'
|
|
'middleware_type': 'authentication'
|
|
'expected_id': 'user123'
|
|
},
|
|
{
|
|
'path': '/protected/users/456/edit'
|
|
'middleware_type': 'authorization'
|
|
'expected_id': '456'
|
|
},
|
|
{
|
|
'path': '/rate-limited/api/users'
|
|
'middleware_type': 'rate_limiting'
|
|
'expected_endpoint': 'users'
|
|
},
|
|
{
|
|
'path': '/cached/articles/789'
|
|
'middleware_type': 'caching'
|
|
'expected_id': '789'
|
|
},
|
|
{
|
|
'path': '/logged/transactions/txn101'
|
|
'middleware_type': 'logging'
|
|
'expected_id': 'txn101'
|
|
},
|
|
{
|
|
'path': '/logged/audit/delete/user'
|
|
'middleware_type': 'audit_logging'
|
|
'expected_action': 'delete'
|
|
'expected_resource': 'user'
|
|
}
|
|
]
|
|
|
|
mut middleware_success := 0
|
|
for test in middleware_tests {
|
|
if match_result := app.fast_router.match_route('GET', test['path']) {
|
|
mut params_correct := true
|
|
|
|
// 验证参数提取
|
|
if expected_id := test['expected_id'] {
|
|
if actual_id := match_result.params['id'] {
|
|
if actual_id != expected_id {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_endpoint := test['expected_endpoint'] {
|
|
if actual_endpoint := match_result.params['endpoint'] {
|
|
if actual_endpoint != expected_endpoint {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_action := test['expected_action'] {
|
|
if actual_action := match_result.params['action'] {
|
|
if actual_action != expected_action {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if expected_resource := test['expected_resource'] {
|
|
if actual_resource := match_result.params['resource'] {
|
|
if actual_resource != expected_resource {
|
|
params_correct = false
|
|
}
|
|
} else {
|
|
params_correct = false
|
|
}
|
|
}
|
|
|
|
if params_correct {
|
|
middleware_success++
|
|
println(' ✅ ${test['path']} - ${test['middleware_type']} 中间件路由')
|
|
} else {
|
|
println(' ❌ ${test['path']} - ${test['middleware_type']} 中间件路由 (参数错误)')
|
|
}
|
|
} else {
|
|
println(' ❌ ${test['path']} - ${test['middleware_type']} 中间件路由 (匹配失败)')
|
|
}
|
|
}
|
|
|
|
println(' 动态中间件路由测试: ${middleware_success}/${middleware_tests.len} 通过')
|
|
} |