2084 lines
60 KiB
Go
2084 lines
60 KiB
Go
// Package handler 提供静态文件处理器功能的测试。
|
||
//
|
||
// 该文件测试静态文件处理器模块的各项功能，包括：
|
||
// - 正常文件访问
|
||
// - 嵌套路径文件
|
||
// - 目录索引文件
|
||
// - 路径遍历安全检查
|
||
// - 索引文件优先级
|
||
// - 构造函数
|
||
// - 文件缓存设置
|
||
// - Gzip 静态文件设置
|
||
// - HEAD 请求处理
|
||
// - 预压缩文件支持
|
||
// - 大文件处理
|
||
// - 符号链接处理
|
||
//
|
||
// 作者：xfy
|
||
package handler
|
||
|
||
import (
|
||
"os"
|
||
"path/filepath"
|
||
"testing"
|
||
"time"
|
||
|
||
"github.com/valyala/fasthttp"
|
||
"rua.plus/lolly/internal/cache"
|
||
"rua.plus/lolly/internal/testutil"
|
||
)
|
||
|
||
// newTestHandler 创建测试用的静态文件处理器。
|
||
//
|
||
// 参数：
|
||
// - t: 测试上下文，用于标记 helper
|
||
// - root: 静态文件根目录
|
||
//
|
||
// 返回值：
|
||
// - *StaticHandler: 配置好索引文件的静态文件处理器（禁用 sendfile）
|
||
func newTestHandler(t *testing.T, root string) *StaticHandler {
|
||
t.Helper()
|
||
return NewStaticHandler(root, "/", []string{"index.html", "index.htm"}, false) // 测试时禁用 sendfile
|
||
}
|
||
|
||
// newTestContext 创建测试用的 fasthttp 请求上下文。
|
||
//
|
||
// 参数：
|
||
// - t: 测试上下文，用于标记 helper
|
||
// - path: 请求路径
|
||
//
|
||
// 返回值：
|
||
// - *fasthttp.RequestCtx: 初始化好的请求上下文
|
||
func newTestContext(t *testing.T, path string) *fasthttp.RequestCtx {
|
||
t.Helper()
|
||
return testutil.NewRequestCtx("GET", path)
|
||
}
|
||
|
||
// TestStaticHandlerHandle 测试静态文件处理器
|
||
func TestStaticHandlerHandle(t *testing.T) {
|
||
tests := []struct {
|
||
setup func(t *testing.T, root string)
|
||
name string
|
||
path string
|
||
wantContent string
|
||
wantStatus int
|
||
skipContent bool
|
||
}{
|
||
{
|
||
name: "正常文件访问",
|
||
setup: func(t *testing.T, root string) {
|
||
t.Helper()
|
||
content := "hello world"
|
||
if err := os.WriteFile(filepath.Join(root, "test.txt"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
},
|
||
path: "/test.txt",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "hello world",
|
||
},
|
||
{
|
||
name: "嵌套路径文件",
|
||
setup: func(t *testing.T, root string) {
|
||
t.Helper()
|
||
subDir := filepath.Join(root, "sub", "dir")
|
||
if err := os.MkdirAll(subDir, 0o755); err != nil {
|
||
t.Fatalf("创建子目录失败: %v", err)
|
||
}
|
||
content := "nested file content"
|
||
if err := os.WriteFile(filepath.Join(subDir, "nested.txt"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建嵌套文件失败: %v", err)
|
||
}
|
||
},
|
||
path: "/sub/dir/nested.txt",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "nested file content",
|
||
},
|
||
{
|
||
name: "目录带索引文件",
|
||
setup: func(t *testing.T, root string) {
|
||
t.Helper()
|
||
dir := filepath.Join(root, "withindex")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
content := "index page"
|
||
if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建索引文件失败: %v", err)
|
||
}
|
||
},
|
||
path: "/withindex/",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "index page",
|
||
},
|
||
{
|
||
name: "目录无索引文件",
|
||
setup: func(t *testing.T, root string) {
|
||
t.Helper()
|
||
dir := filepath.Join(root, "noindex")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
},
|
||
path: "/noindex/",
|
||
wantStatus: fasthttp.StatusForbidden,
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "文件不存在",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
// 不创建任何文件
|
||
},
|
||
path: "/nonexistent.txt",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "空路径访问根目录无索引",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
// root 目录没有索引文件
|
||
},
|
||
path: "/",
|
||
wantStatus: fasthttp.StatusForbidden,
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "根目录有索引文件",
|
||
setup: func(t *testing.T, root string) {
|
||
t.Helper()
|
||
content := "root index"
|
||
if err := os.WriteFile(filepath.Join(root, "index.html"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建根索引文件失败: %v", err)
|
||
}
|
||
},
|
||
path: "/",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "root index",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
// 创建临时目录
|
||
tmpDir := t.TempDir()
|
||
|
||
// 设置测试文件
|
||
tt.setup(t, tmpDir)
|
||
|
||
// 创建处理器和上下文
|
||
handler := newTestHandler(t, tmpDir)
|
||
ctx := newTestContext(t, tt.path)
|
||
|
||
// 执行请求
|
||
handler.Handle(ctx)
|
||
|
||
// 验证状态码
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("Handle() 状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
// 验证内容（如果需要）
|
||
if !tt.skipContent && tt.wantContent != "" {
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("Handle() 内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandlerHandle_PathTraversalSecurity 测试路径遍历安全检查
|
||
// 注意：fasthttp 会自动规范化路径，移除 ../ 组件
|
||
// 安全检查 strings.Contains(path, "..") 检测文件名中包含 ".." 的情况
|
||
func TestStaticHandlerHandle_PathTraversalSecurity(t *testing.T) {
|
||
tests := []struct {
|
||
setup func(t *testing.T, root string)
|
||
name string
|
||
path string
|
||
description string
|
||
wantStatus int
|
||
}{
|
||
{
|
||
name: "文件名包含双点 - 安全检查拦截",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
// 不创建任何文件
|
||
},
|
||
path: "/file..txt",
|
||
wantStatus: fasthttp.StatusForbidden,
|
||
description: "路径包含 '..' 字符串，触发安全检查返回 403",
|
||
},
|
||
{
|
||
name: "路径末尾双点 - 安全检查拦截",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
},
|
||
path: "/foo/..",
|
||
wantStatus: fasthttp.StatusForbidden,
|
||
description: "路径末尾包含 '..'，触发安全检查返回 403",
|
||
},
|
||
{
|
||
name: "隐藏文件 .hidden - 文件不存在",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
},
|
||
path: "/.hidden",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
description: "单点开头的隐藏文件不触发安全检查，文件不存在返回 404",
|
||
},
|
||
{
|
||
name: "文件名包含多点 ...txt - 安全检查拦截",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
},
|
||
path: "/file...txt",
|
||
wantStatus: fasthttp.StatusForbidden,
|
||
description: "包含连续多点（含 '..'）触发安全检查返回 403",
|
||
},
|
||
{
|
||
name: "fasthttp 规范化后的路径 - 文件不存在",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
// fasthttp 将 /../secret.txt 规范化为 /secret.txt
|
||
},
|
||
path: "/../secret.txt",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
description: "fasthttp 自动规范化路径移除 ../，结果路径文件不存在返回 404",
|
||
},
|
||
{
|
||
name: "URL 编码路径遍历 - fasthttp 规范化",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
// fasthttp 解码 %2e%2e 为 .. 并规范化路径
|
||
},
|
||
path: "/%2e%2e/secret.txt",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
description: "fasthttp 解码 URL 编码后规范化路径，文件不存在返回 404",
|
||
},
|
||
{
|
||
name: "混合 URL 编码 - fasthttp 规范化",
|
||
setup: func(_ *testing.T, _ string) {
|
||
t.Helper()
|
||
},
|
||
path: "/%2e%2e%2fsecret.txt",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
description: "fasthttp 解码并规范化路径，文件不存在返回 404",
|
||
},
|
||
{
|
||
name: "路径中含 ../ - fasthttp 规范化",
|
||
setup: func(t *testing.T, root string) {
|
||
t.Helper()
|
||
// 创建目标文件供测试
|
||
if err := os.WriteFile(filepath.Join(root, "bar.txt"), []byte("bar"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
path: "/foo/../bar.txt",
|
||
wantStatus: fasthttp.StatusOK,
|
||
description: "fasthttp 规范化 /foo/../bar.txt 为 /bar.txt，文件存在返回 200",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
tt.setup(t, tmpDir)
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
ctx := newTestContext(t, tt.path)
|
||
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("Handle() 状态码 = %d, want %d\n说明: %s", got, tt.wantStatus, tt.description)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandlerHandle_IndexFallback 测试索引文件优先级
|
||
func TestStaticHandlerHandle_IndexFallback(t *testing.T) {
|
||
t.Run("优先 index.html", func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
dir := filepath.Join(tmpDir, "testdir")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
|
||
// 创建两个索引文件
|
||
if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("html content"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.html 失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(dir, "index.htm"), []byte("htm content"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.htm 失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
ctx := newTestContext(t, "/testdir/")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
// 应返回 index.html 而非 index.htm
|
||
got := string(ctx.Response.Body())
|
||
if got != "html content" {
|
||
t.Errorf("内容 = %q, want %q", got, "html content")
|
||
}
|
||
})
|
||
|
||
t.Run("无 index.html 时使用 index.htm", func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
dir := filepath.Join(tmpDir, "testdir")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
|
||
// 仅创建 index.htm
|
||
if err := os.WriteFile(filepath.Join(dir, "index.htm"), []byte("htm content"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.htm 失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
ctx := newTestContext(t, "/testdir/")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
got := string(ctx.Response.Body())
|
||
if got != "htm content" {
|
||
t.Errorf("内容 = %q, want %q", got, "htm content")
|
||
}
|
||
})
|
||
|
||
t.Run("无索引文件时返回 403", func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
dir := filepath.Join(tmpDir, "testdir")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
|
||
// 创建一个非索引文件
|
||
if err := os.WriteFile(filepath.Join(dir, "other.txt"), []byte("other content"), 0o644); err != nil {
|
||
t.Fatalf("创建 other.txt 失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
ctx := newTestContext(t, "/testdir/")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusForbidden {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusForbidden)
|
||
}
|
||
})
|
||
|
||
t.Run("目录不带斜杠结尾", func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
dir := filepath.Join(tmpDir, "testdir")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
|
||
// 创建索引文件
|
||
if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("index"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.html 失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
ctx := newTestContext(t, "/testdir") // 不带斜杠
|
||
handler.Handle(ctx)
|
||
|
||
// 目录不带斜杠也应该能访问索引文件
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestNewStaticHandler 测试静态文件处理器构造函数
|
||
func TestNewStaticHandler(t *testing.T) {
|
||
t.Run("正常创建", func(t *testing.T) {
|
||
root := "/var/www"
|
||
index := []string{"index.html", "index.htm"}
|
||
handler := NewStaticHandler(root, "/", index, true)
|
||
|
||
if handler == nil {
|
||
t.Fatal("NewStaticHandler() 返回 nil")
|
||
}
|
||
// root 被规范化为带尾部斜杠的形式
|
||
expectedRoot := "/var/www/"
|
||
if handler.root != expectedRoot {
|
||
t.Errorf("handler.root = %q, want %q", handler.root, expectedRoot)
|
||
}
|
||
if len(handler.index) != len(index) {
|
||
t.Errorf("len(handler.index) = %d, want %d", len(handler.index), len(index))
|
||
}
|
||
})
|
||
|
||
t.Run("空索引列表", func(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", nil, false)
|
||
if handler == nil {
|
||
t.Fatal("NewStaticHandler() 返回 nil")
|
||
}
|
||
if handler.index != nil {
|
||
t.Errorf("handler.index 应为 nil")
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestStaticHandler_SetFileCache 测试设置文件缓存
|
||
func TestStaticHandler_SetFileCache(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", nil, false)
|
||
|
||
// 设置 nil 缓存
|
||
handler.SetFileCache(nil)
|
||
if handler.fileCache != nil {
|
||
t.Error("Expected nil fileCache")
|
||
}
|
||
|
||
// 设置非 nil 缓存（使用 mock 或简单验证）
|
||
// 由于 FileCache 接口需要实现，这里主要验证不会 panic
|
||
}
|
||
|
||
// TestStaticHandler_SetGzipStatic 测试设置 Gzip 静态文件
|
||
func TestStaticHandler_SetGzipStatic(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", nil, false)
|
||
|
||
// 启用 gzip
|
||
handler.SetGzipStatic(true, nil, []string{".gz", ".gzip"})
|
||
if handler.gzipStatic == nil {
|
||
t.Error("Expected gzipStatic to be non-nil")
|
||
}
|
||
|
||
// 禁用 gzip
|
||
handler.SetGzipStatic(false, nil, nil)
|
||
// gzipStatic 保持不变（SetGzipStatic 只在 enabled=true 时设置）
|
||
}
|
||
|
||
// TestStaticHandler_Handle_HeadRequest 测试 HEAD 请求
|
||
func TestStaticHandler_Handle_HeadRequest(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
content := "head request test"
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "test.txt"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
|
||
ctx := &fasthttp.RequestCtx{}
|
||
ctx.Request.SetRequestURI("/test.txt")
|
||
ctx.Request.Header.SetMethod("HEAD")
|
||
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
// 验证 Content-Type 设置正确
|
||
ct := string(ctx.Response.Header.ContentType())
|
||
if ct == "" {
|
||
t.Error("Expected Content-Type to be set")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_WithCache 测试带缓存的文件处理
|
||
func TestStaticHandler_Handle_WithCache(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
content := "cached content test"
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "test.txt"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
// 设置 nil 缓存，验证不会 panic
|
||
handler.SetFileCache(nil)
|
||
|
||
ctx := &fasthttp.RequestCtx{}
|
||
ctx.Request.SetRequestURI("/test.txt")
|
||
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_Precompressed 测试预压缩文件
|
||
func TestStaticHandler_Handle_Precompressed(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建原始文件和 gzip 压缩版本
|
||
content := "test content for gzip"
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "test.txt"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
// 创建 .gz 文件（模拟预压缩）
|
||
gzContent := []byte("gzipped content")
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "test.txt.gz"), gzContent, 0o644); err != nil {
|
||
t.Fatalf("创建 gzip 文件失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", nil, false)
|
||
handler.SetGzipStatic(true, nil, []string{".gz"})
|
||
|
||
ctx := &fasthttp.RequestCtx{}
|
||
ctx.Request.SetRequestURI("/test.txt")
|
||
ctx.Request.Header.Set("Accept-Encoding", "gzip")
|
||
|
||
handler.Handle(ctx)
|
||
|
||
// 应返回预压缩内容
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_LargeFile 测试大文件处理
|
||
func TestStaticHandler_Handle_LargeFile(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建一个较大的文件 (> 8KB 触发 sendfile 路径)
|
||
largeContent := make([]byte, 16*1024)
|
||
for i := range largeContent {
|
||
largeContent[i] = byte(i % 256)
|
||
}
|
||
|
||
tmpFile := filepath.Join(tmpDir, "large.bin")
|
||
if err := os.WriteFile(tmpFile, largeContent, 0o644); err != nil {
|
||
t.Fatalf("创建大文件失败: %v", err)
|
||
}
|
||
|
||
// 使用 sendfile 启用的处理器
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, true)
|
||
|
||
ctx := &fasthttp.RequestCtx{}
|
||
ctx.Request.SetRequestURI("/large.bin")
|
||
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_Symlink 测试符号链接处理
|
||
func TestStaticHandler_Handle_Symlink(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建目标文件
|
||
targetContent := "symlink target"
|
||
targetFile := filepath.Join(tmpDir, "target.txt")
|
||
if err := os.WriteFile(targetFile, []byte(targetContent), 0o644); err != nil {
|
||
t.Fatalf("创建目标文件失败: %v", err)
|
||
}
|
||
|
||
// 创建符号链接
|
||
linkFile := filepath.Join(tmpDir, "link.txt")
|
||
if err := os.Symlink(targetFile, linkFile); err != nil {
|
||
t.Fatalf("创建符号链接失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
|
||
ctx := &fasthttp.RequestCtx{}
|
||
ctx.Request.SetRequestURI("/link.txt")
|
||
|
||
handler.Handle(ctx)
|
||
|
||
// 符号链接应该能正常访问
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_SetTryFiles 测试 SetTryFiles 配置设置
|
||
func TestStaticHandler_SetTryFiles(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
tryFiles []string
|
||
wantTryFiles []string
|
||
tryFilesPass bool
|
||
wantPass bool
|
||
}{
|
||
{
|
||
name: "基本配置",
|
||
tryFiles: []string{"$uri", "$uri/", "/index.html"},
|
||
tryFilesPass: false,
|
||
wantTryFiles: []string{"$uri", "$uri/", "/index.html"},
|
||
wantPass: false,
|
||
},
|
||
{
|
||
name: "启用 tryFilesPass",
|
||
tryFiles: []string{"$uri", "/fallback.html"},
|
||
tryFilesPass: true,
|
||
wantTryFiles: []string{"$uri", "/fallback.html"},
|
||
wantPass: true,
|
||
},
|
||
{
|
||
name: "空配置",
|
||
tryFiles: []string{},
|
||
tryFilesPass: false,
|
||
wantTryFiles: []string{},
|
||
wantPass: false,
|
||
},
|
||
{
|
||
name: "单一项配置",
|
||
tryFiles: []string{"/app.html"},
|
||
tryFilesPass: false,
|
||
wantTryFiles: []string{"/app.html"},
|
||
wantPass: false,
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", []string{"index.html"}, false)
|
||
router := NewRouter()
|
||
|
||
handler.SetTryFiles(tt.tryFiles, tt.tryFilesPass, router)
|
||
|
||
// 验证配置
|
||
if len(handler.tryFiles) != len(tt.wantTryFiles) {
|
||
t.Errorf("tryFiles length = %d, want %d", len(handler.tryFiles), len(tt.wantTryFiles))
|
||
}
|
||
for i, v := range tt.wantTryFiles {
|
||
if handler.tryFiles[i] != v {
|
||
t.Errorf("tryFiles[%d] = %q, want %q", i, handler.tryFiles[i], v)
|
||
}
|
||
}
|
||
if handler.tryFilesPass != tt.wantPass {
|
||
t.Errorf("tryFilesPass = %v, want %v", handler.tryFilesPass, tt.wantPass)
|
||
}
|
||
if handler.router != router {
|
||
t.Error("router 未正确设置")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_resolveTryFilePath 测试 resolveTryFilePath 占位符解析
|
||
func TestStaticHandler_resolveTryFilePath(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", []string{"index.html"}, false)
|
||
|
||
tests := []struct {
|
||
name string
|
||
tryFile string
|
||
relPath string
|
||
wantResult string
|
||
}{
|
||
{
|
||
name: "$uri 占位符",
|
||
tryFile: "$uri",
|
||
relPath: "/api/user",
|
||
wantResult: "/api/user",
|
||
},
|
||
{
|
||
name: "$uri/ 占位符",
|
||
tryFile: "$uri/",
|
||
relPath: "/api/user",
|
||
wantResult: "/api/user/",
|
||
},
|
||
{
|
||
name: "绝对路径",
|
||
tryFile: "/index.html",
|
||
relPath: "/api/user",
|
||
wantResult: "index.html",
|
||
},
|
||
{
|
||
name: "普通文件名",
|
||
tryFile: "fallback.html",
|
||
relPath: "/api/user",
|
||
wantResult: "fallback.html",
|
||
},
|
||
{
|
||
name: "根路径 $uri",
|
||
tryFile: "$uri",
|
||
relPath: "/",
|
||
wantResult: "/",
|
||
},
|
||
{
|
||
name: "嵌套路径 $uri",
|
||
tryFile: "$uri",
|
||
relPath: "/assets/js/app.js",
|
||
wantResult: "/assets/js/app.js",
|
||
},
|
||
{
|
||
name: "带查询风格路径",
|
||
tryFile: "$uri",
|
||
relPath: "/path/to/file.txt",
|
||
wantResult: "/path/to/file.txt",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := handler.resolveTryFilePath(tt.tryFile, tt.relPath)
|
||
if got != tt.wantResult {
|
||
t.Errorf("resolveTryFilePath(%q, %q) = %q, want %q", tt.tryFile, tt.relPath, got, tt.wantResult)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_handleTryFiles 测试 handleTryFiles 功能
|
||
func TestStaticHandler_handleTryFiles(t *testing.T) {
|
||
tests := []struct {
|
||
setup func(t *testing.T, root string)
|
||
name string
|
||
path string
|
||
wantContent string
|
||
tryFiles []string
|
||
wantStatus int
|
||
skipContent bool
|
||
}{
|
||
{
|
||
name: "$uri 找到文件",
|
||
setup: func(t *testing.T, root string) {
|
||
if err := os.WriteFile(filepath.Join(root, "app.js"), []byte("app content"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "$uri/", "/index.html"},
|
||
path: "/app.js",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "app content",
|
||
},
|
||
{
|
||
name: "$uri 未找到回退到 $uri/",
|
||
setup: func(t *testing.T, root string) {
|
||
dir := filepath.Join(root, "assets")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("assets index"), 0o644); err != nil {
|
||
t.Fatalf("创建索引文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "$uri/", "/index.html"},
|
||
path: "/assets",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "assets index",
|
||
},
|
||
{
|
||
name: "回退到 fallback 文件",
|
||
setup: func(t *testing.T, root string) {
|
||
if err := os.WriteFile(filepath.Join(root, "index.html"), []byte("spa fallback"), 0o644); err != nil {
|
||
t.Fatalf("创建 fallback 文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "$uri/", "/index.html"},
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "spa fallback",
|
||
},
|
||
{
|
||
name: "所有 try_files 都未找到",
|
||
setup: func(_ *testing.T, _ string) {
|
||
// 不创建任何文件
|
||
},
|
||
tryFiles: []string{"$uri", "$uri/", "/index.html"},
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "嵌套目录回退",
|
||
setup: func(t *testing.T, root string) {
|
||
if err := os.WriteFile(filepath.Join(root, "app.html"), []byte("app shell"), 0o644); err != nil {
|
||
t.Fatalf("创建 fallback 文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "/app.html"},
|
||
path: "/user/profile",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "app shell",
|
||
},
|
||
{
|
||
name: "路径前缀剥离",
|
||
setup: func(t *testing.T, root string) {
|
||
apiDir := filepath.Join(root, "api")
|
||
if err := os.MkdirAll(apiDir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(apiDir, "data.json"), []byte("json data"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri"},
|
||
path: "/static/api/data.json",
|
||
wantStatus: fasthttp.StatusNotFound, // 路径前缀剥离后找不到
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "空 try_files 数组",
|
||
setup: func(t *testing.T, root string) {
|
||
if err := os.WriteFile(filepath.Join(root, "test.txt"), []byte("test"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{},
|
||
path: "/test.txt",
|
||
wantStatus: fasthttp.StatusOK, // 空 try_files 走标准处理流程
|
||
wantContent: "test",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
tt.setup(t, tmpDir)
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, false)
|
||
handler.SetTryFiles(tt.tryFiles, false, nil)
|
||
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
if !tt.skipContent && tt.wantContent != "" {
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_handleInternalRedirect 测试内部重定向功能
|
||
func TestStaticHandler_handleInternalRedirect(t *testing.T) {
|
||
tests := []struct {
|
||
setup func(t *testing.T, root string)
|
||
name string
|
||
path string
|
||
wantContent string
|
||
tryFiles []string
|
||
wantStatus int
|
||
tryFilesPass bool
|
||
skipContent bool
|
||
}{
|
||
{
|
||
name: "tryFilesPass false 直接服务文件",
|
||
setup: func(t *testing.T, root string) {
|
||
if err := os.WriteFile(filepath.Join(root, "index.html"), []byte("index content"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "/index.html"},
|
||
tryFilesPass: false,
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "index content",
|
||
},
|
||
{
|
||
name: "tryFilesPass true 触发重定向",
|
||
setup: func(t *testing.T, root string) {
|
||
if err := os.WriteFile(filepath.Join(root, "fallback.txt"), []byte("fallback content"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "/fallback.txt"},
|
||
tryFilesPass: true,
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "fallback content",
|
||
},
|
||
{
|
||
name: "内部重定向目标不存在",
|
||
setup: func(_ *testing.T, _ string) {
|
||
// 不创建 fallback 文件
|
||
},
|
||
tryFiles: []string{"$uri", "/fallback.html"},
|
||
tryFilesPass: false,
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "内部重定向目标是目录",
|
||
setup: func(t *testing.T, root string) {
|
||
dir := filepath.Join(root, "fallback")
|
||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
// 在 fallback 目录中创建一个 index.html
|
||
if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("fallback index"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.html 失败: %v", err)
|
||
}
|
||
},
|
||
tryFiles: []string{"$uri", "$uri/", "/fallback"},
|
||
tryFilesPass: false,
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "fallback index",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
tt.setup(t, tmpDir)
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, false)
|
||
router := NewRouter()
|
||
handler.SetTryFiles(tt.tryFiles, tt.tryFilesPass, router)
|
||
|
||
// 注册路由处理器用于测试 tryFilesPass 重定向
|
||
if tt.tryFilesPass {
|
||
router.GET("/{filepath:*}", func(ctx *fasthttp.RequestCtx) {
|
||
// 通配符路由，可以匹配任何路径
|
||
path := string(ctx.Path())
|
||
// 从 root 读取文件
|
||
filePath := filepath.Join(tmpDir, path[1:]) // 去掉开头的 /
|
||
data, err := os.ReadFile(filePath)
|
||
if err != nil {
|
||
ctx.SetStatusCode(fasthttp.StatusNotFound)
|
||
ctx.SetBodyString("Not Found")
|
||
return
|
||
}
|
||
ctx.SetStatusCode(fasthttp.StatusOK)
|
||
ctx.SetBody(data)
|
||
})
|
||
}
|
||
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
if !tt.skipContent && tt.wantContent != "" {
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_TryFilesSPA 测试 SPA 场景下的 try_files
|
||
func TestStaticHandler_TryFilesSPA(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建 SPA 文件结构
|
||
// index.html - 主应用入口
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "index.html"), []byte("<!DOCTYPE html><html><body>SPA App</body></html>"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.html 失败: %v", err)
|
||
}
|
||
|
||
// 静态资源文件
|
||
assetsDir := filepath.Join(tmpDir, "assets")
|
||
if err := os.MkdirAll(assetsDir, 0o755); err != nil {
|
||
t.Fatalf("创建 assets 目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(assetsDir, "app.js"), []byte("console.log('app')"), 0o644); err != nil {
|
||
t.Fatalf("创建 app.js 失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(assetsDir, "style.css"), []byte("body { margin: 0 }"), 0o644); err != nil {
|
||
t.Fatalf("创建 style.css 失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, false)
|
||
handler.SetTryFiles([]string{"$uri", "$uri/", "/index.html"}, false, nil)
|
||
|
||
tests := []struct {
|
||
name string
|
||
path string
|
||
wantContent string
|
||
wantStatus int
|
||
}{
|
||
{
|
||
name: "访问存在的静态资源",
|
||
path: "/assets/app.js",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "console.log('app')",
|
||
},
|
||
{
|
||
name: "访问存在的 CSS 文件",
|
||
path: "/assets/style.css",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "body { margin: 0 }",
|
||
},
|
||
{
|
||
name: "访问前端路由回退到 index.html",
|
||
path: "/dashboard",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "<!DOCTYPE html><html><body>SPA App</body></html>",
|
||
},
|
||
{
|
||
name: "访问嵌套前端路由",
|
||
path: "/user/profile/settings",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "<!DOCTYPE html><html><body>SPA App</body></html>",
|
||
},
|
||
{
|
||
name: "访问根路径",
|
||
path: "/",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "<!DOCTYPE html><html><body>SPA App</body></html>",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_TryFilesWithPathPrefix 测试带路径前缀的 try_files
|
||
func TestStaticHandler_TryFilesWithPathPrefix(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建 API 模拟文件
|
||
apiDir := filepath.Join(tmpDir, "api")
|
||
if err := os.MkdirAll(apiDir, 0o755); err != nil {
|
||
t.Fatalf("创建 api 目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(apiDir, "users.json"), []byte("[]"), 0o644); err != nil {
|
||
t.Fatalf("创建 users.json 失败: %v", err)
|
||
}
|
||
|
||
// 创建静态文件
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "index.html"), []byte("static index"), 0o644); err != nil {
|
||
t.Fatalf("创建 index.html 失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(tmpDir, "/static", []string{"index.html"}, false)
|
||
handler.SetTryFiles([]string{"$uri", "$uri/", "/index.html"}, false, nil)
|
||
|
||
tests := []struct {
|
||
name string
|
||
path string
|
||
wantContent string
|
||
wantStatus int
|
||
skipContent bool
|
||
}{
|
||
{
|
||
name: "带前缀访问文件",
|
||
path: "/static/api/users.json",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "[]",
|
||
},
|
||
{
|
||
name: "带前缀访问目录",
|
||
path: "/static/api/",
|
||
wantStatus: fasthttp.StatusOK, // 目录无索引文件，但会回退到 /index.html
|
||
wantContent: "static index",
|
||
},
|
||
{
|
||
name: "前缀剥离后回退",
|
||
path: "/static/unknown",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "static index",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
if !tt.skipContent {
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Alias 测试 alias 路径替换功能
|
||
func TestStaticHandler_Alias(t *testing.T) {
|
||
tests := []struct {
|
||
setup func(t *testing.T, aliasDir string)
|
||
name string
|
||
alias string
|
||
pathPrefix string
|
||
path string
|
||
wantContent string
|
||
wantStatus int
|
||
skipContent bool
|
||
}{
|
||
{
|
||
name: "alias 基础替换",
|
||
setup: func(t *testing.T, aliasDir string) {
|
||
if err := os.WriteFile(filepath.Join(aliasDir, "logo.png"), []byte("png content"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
alias: "/alias/images/",
|
||
pathPrefix: "/images/",
|
||
path: "/images/logo.png",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "png content",
|
||
},
|
||
{
|
||
name: "alias 嵌套路径",
|
||
setup: func(t *testing.T, aliasDir string) {
|
||
subDir := filepath.Join(aliasDir, "icons")
|
||
if err := os.MkdirAll(subDir, 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(subDir, "app.png"), []byte("app icon"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
alias: "/alias/img/",
|
||
pathPrefix: "/images/",
|
||
path: "/images/icons/app.png",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "app icon",
|
||
},
|
||
{
|
||
name: "alias 目录索引",
|
||
setup: func(t *testing.T, aliasDir string) {
|
||
if err := os.WriteFile(filepath.Join(aliasDir, "index.html"), []byte("alias index"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
alias: "/alias/images/",
|
||
pathPrefix: "/images/",
|
||
path: "/images/",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "alias index",
|
||
},
|
||
{
|
||
name: "alias 文件不存在",
|
||
setup: func(_ *testing.T, _ string) {
|
||
// 不创建任何文件
|
||
},
|
||
alias: "/alias/images/",
|
||
pathPrefix: "/images/",
|
||
path: "/images/notfound.png",
|
||
wantStatus: fasthttp.StatusNotFound,
|
||
skipContent: true,
|
||
},
|
||
{
|
||
name: "root 与 alias 互斥 - 使用 alias",
|
||
setup: func(t *testing.T, aliasDir string) {
|
||
if err := os.WriteFile(filepath.Join(aliasDir, "file.txt"), []byte("from alias"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
},
|
||
alias: "/alias/images/",
|
||
pathPrefix: "/images/",
|
||
path: "/images/file.txt",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "from alias",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
// 创建临时目录作为 alias 目录
|
||
aliasDir := t.TempDir()
|
||
tt.setup(t, aliasDir)
|
||
|
||
// 创建处理器（使用 alias）
|
||
handler := &StaticHandler{
|
||
alias: aliasDir,
|
||
pathPrefix: tt.pathPrefix,
|
||
pathPrefixLen: len(tt.pathPrefix),
|
||
index: []string{"index.html"},
|
||
}
|
||
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
if !tt.skipContent && tt.wantContent != "" {
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_AliasVsRoot 测试 alias 和 root 的行为区别
|
||
func TestStaticHandler_AliasVsRoot(t *testing.T) {
|
||
// root 目录
|
||
rootDir := t.TempDir()
|
||
// alias 目录
|
||
aliasDir := t.TempDir()
|
||
|
||
// 在 root 创建子目录和文件
|
||
imagesDir := filepath.Join(rootDir, "images")
|
||
if err := os.MkdirAll(imagesDir, 0o755); err != nil {
|
||
t.Fatalf("创建 images 目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(imagesDir, "logo.png"), []byte("from root"), 0o644); err != nil {
|
||
t.Fatalf("创建 root 文件失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(aliasDir, "logo.png"), []byte("from alias"), 0o644); err != nil {
|
||
t.Fatalf("创建 alias 文件失败: %v", err)
|
||
}
|
||
|
||
tests := []struct {
|
||
name string
|
||
handler *StaticHandler
|
||
path string
|
||
wantContent string
|
||
}{
|
||
{
|
||
name: "root 模式：请求路径附加到 root",
|
||
handler: NewStaticHandler(rootDir, "/", []string{"index.html"}, false),
|
||
path: "/images/logo.png",
|
||
wantContent: "from root", // /var/www/images/logo.png
|
||
},
|
||
{
|
||
name: "alias 模式：请求路径替换匹配部分",
|
||
handler: &StaticHandler{
|
||
alias: aliasDir,
|
||
pathPrefix: "/images/",
|
||
pathPrefixLen: len("/images/"),
|
||
index: []string{"index.html"},
|
||
},
|
||
path: "/images/logo.png",
|
||
wantContent: "from alias", // /alias/logo.png（images/被替换）
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
ctx := newTestContext(t, tt.path)
|
||
tt.handler.Handle(ctx)
|
||
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_SetAlias 测试 SetAlias 方法
|
||
func TestStaticHandler_SetAlias(t *testing.T) {
|
||
t.Run("设置 alias", func(t *testing.T) {
|
||
handler := NewStaticHandler("/root", "/", nil, false)
|
||
|
||
if handler.alias != "" {
|
||
t.Error("初始 alias 应为空")
|
||
}
|
||
|
||
handler.SetAlias("/alias")
|
||
|
||
if handler.alias != "/alias" {
|
||
t.Errorf("GetAlias() = %q, want %q", handler.alias, "/alias")
|
||
}
|
||
if handler.root != "" {
|
||
t.Error("设置 alias 后 root 应被清空")
|
||
}
|
||
})
|
||
|
||
t.Run("设置 root 清除 alias", func(t *testing.T) {
|
||
handler := NewStaticHandler("/root", "/", nil, false)
|
||
|
||
// root 被规范化为带尾部斜杠的形式
|
||
expectedRoot := "/root/"
|
||
if handler.root != expectedRoot {
|
||
t.Errorf("root = %q, want %q", handler.root, expectedRoot)
|
||
}
|
||
if handler.alias != "" {
|
||
t.Error("初始 alias 应为空")
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestStaticHandler_AliasWithTryFiles 测试 alias 与 try_files 组合
|
||
func TestStaticHandler_AliasWithTryFiles(t *testing.T) {
|
||
aliasDir := t.TempDir()
|
||
|
||
// 创建测试文件
|
||
if err := os.WriteFile(filepath.Join(aliasDir, "app.js"), []byte("app content"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(aliasDir, "index.html"), []byte("fallback"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
|
||
handler := &StaticHandler{
|
||
alias: aliasDir,
|
||
pathPrefix: "/static/",
|
||
pathPrefixLen: len("/static/"),
|
||
index: []string{"index.html"},
|
||
}
|
||
handler.SetTryFiles([]string{"$uri", "/index.html"}, false, nil)
|
||
|
||
tests := []struct {
|
||
name string
|
||
path string
|
||
wantContent string
|
||
wantStatus int
|
||
}{
|
||
{
|
||
name: "找到文件",
|
||
path: "/static/app.js",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "app content",
|
||
},
|
||
{
|
||
name: "回退到 index.html",
|
||
path: "/static/nonexistent",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "fallback",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
got := string(ctx.Response.Body())
|
||
if got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_TryFilesEdgeCases 测试 try_files 边界情况
|
||
func TestStaticHandler_TryFilesEdgeCases(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建测试文件
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "file with spaces.txt"), []byte("spaces"), 0o644); err != nil {
|
||
t.Fatalf("创建带空格文件失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, false)
|
||
handler.SetTryFiles([]string{"$uri", "/index.html"}, false, nil)
|
||
|
||
tests := []struct {
|
||
name string
|
||
path string
|
||
wantStatus int
|
||
}{
|
||
{
|
||
name: "路径遍历攻击被阻止 - fasthttp 规范化",
|
||
path: "/../secret",
|
||
wantStatus: fasthttp.StatusNotFound, // fasthttp 规范化为 /secret，文件不存在返回 404
|
||
},
|
||
{
|
||
name: "双点号在路径中被阻止",
|
||
path: "/file..name",
|
||
wantStatus: fasthttp.StatusForbidden,
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_LargeFileContentType 测试大文件 sendfile 路径的 Content-Type
|
||
func TestStaticHandler_LargeFileContentType(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建大于 8KB 的文件
|
||
largeContent := make([]byte, 16*1024)
|
||
for i := range largeContent {
|
||
largeContent[i] = byte(i % 256)
|
||
}
|
||
|
||
tests := []struct {
|
||
ext string
|
||
expected string
|
||
}{
|
||
{".css", "text/css; charset=utf-8"},
|
||
{".js", "text/javascript; charset=utf-8"},
|
||
{".webmanifest", "application/manifest+json"},
|
||
{".webm", "video/webm"},
|
||
{".otf", "font/otf"},
|
||
}
|
||
|
||
for _, tc := range tests {
|
||
t.Run(tc.ext, func(t *testing.T) {
|
||
filePath := filepath.Join(tmpDir, "large"+tc.ext)
|
||
if err := os.WriteFile(filePath, largeContent, 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", nil, true) // 启用 sendfile
|
||
ctx := &fasthttp.RequestCtx{}
|
||
ctx.Request.SetRequestURI("/large" + tc.ext)
|
||
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
ct := string(ctx.Response.Header.ContentType())
|
||
if ct != tc.expected {
|
||
t.Errorf("Content-Type = %q, want %q", ct, tc.expected)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestResolveTryFilePathWithDynamicSuffix 测试动态后缀解析
|
||
func TestResolveTryFilePathWithDynamicSuffix(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", []string{"index.html"}, false)
|
||
|
||
tests := []struct {
|
||
name string
|
||
tryFile string
|
||
relPath string
|
||
wantResult string
|
||
}{
|
||
// 基本占位符
|
||
{name: "$uri", tryFile: "$uri", relPath: "/api/user", wantResult: "/api/user"},
|
||
{name: "$uri/", tryFile: "$uri/", relPath: "/api/user", wantResult: "/api/user/"},
|
||
|
||
// 动态后缀 - 正常路径
|
||
{name: "$uri.html 正常", tryFile: "$uri.html", relPath: "/about", wantResult: "/about.html"},
|
||
{name: "$uri.json 正常", tryFile: "$uri.json", relPath: "/api/data", wantResult: "/api/data.json"},
|
||
{name: "$uri.css 正常", tryFile: "$uri.css", relPath: "/styles/main", wantResult: "/styles/main.css"},
|
||
|
||
// 动态后缀 - 根路径边界（返回空字符串）
|
||
{name: "$uri.html 根路径", tryFile: "$uri.html", relPath: "/", wantResult: ""},
|
||
{name: "$uri.json 根路径", tryFile: "$uri.json", relPath: "/", wantResult: ""},
|
||
|
||
// 动态后缀 - 子目录路径（正常处理）
|
||
{name: "$uri.html 子目录", tryFile: "$uri.html", relPath: "/api/", wantResult: "/api/.html"},
|
||
{name: "$uri.json 子目录", tryFile: "$uri.json", relPath: "/v1/", wantResult: "/v1/.json"},
|
||
|
||
// 绝对路径
|
||
{name: "绝对路径", tryFile: "/index.html", relPath: "/api/user", wantResult: "index.html"},
|
||
{name: "绝对路径嵌套", tryFile: "/fallback/app.html", relPath: "/any", wantResult: "fallback/app.html"},
|
||
|
||
// 相对路径
|
||
{name: "相对路径", tryFile: "fallback.html", relPath: "/api/user", wantResult: "fallback.html"},
|
||
{name: "相对路径带连字符", tryFile: "app-shell.html", relPath: "/any", wantResult: "app-shell.html"},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := handler.resolveTryFilePath(tt.tryFile, tt.relPath)
|
||
if got != tt.wantResult {
|
||
t.Errorf("resolveTryFilePath(%q, %q) = %q, want %q",
|
||
tt.tryFile, tt.relPath, got, tt.wantResult)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_TryFilesWithDynamicSuffix 测试动态后缀集成
|
||
func TestStaticHandler_TryFilesWithDynamicSuffix(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建测试文件
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "about.html"), []byte("about page"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
if err := os.MkdirAll(filepath.Join(tmpDir, "api"), 0o755); err != nil {
|
||
t.Fatalf("创建目录失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "api", "data.json"), []byte("{\"data\":true}"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "index.html"), []byte("fallback"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, false)
|
||
handler.SetTryFiles([]string{"$uri", "$uri.html", "/index.html"}, false, nil)
|
||
|
||
tests := []struct {
|
||
name string
|
||
path string
|
||
wantContent string
|
||
wantStatus int
|
||
}{
|
||
{
|
||
name: "找到 $uri.html",
|
||
path: "/about",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "about page",
|
||
},
|
||
{
|
||
name: "回退到 /index.html",
|
||
path: "/nonexistent",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "fallback",
|
||
},
|
||
{
|
||
name: "根路径回退到 /index.html",
|
||
path: "/",
|
||
wantStatus: fasthttp.StatusOK,
|
||
wantContent: "fallback",
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
ctx := newTestContext(t, tt.path)
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != tt.wantStatus {
|
||
t.Errorf("状态码 = %d, want %d", got, tt.wantStatus)
|
||
}
|
||
|
||
if got := string(ctx.Response.Body()); got != tt.wantContent {
|
||
t.Errorf("内容 = %q, want %q", got, tt.wantContent)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_TryFilesRootPathFallback 测试根路径回退
|
||
func TestStaticHandler_TryFilesRootPathFallback(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建 index.html 作为根路径回退
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "index.html"), []byte("root fallback"), 0o644); err != nil {
|
||
t.Fatalf("创建文件失败: %v", err)
|
||
}
|
||
|
||
// 注意：不创建 /.html 文件，测试根路径边界情况
|
||
handler := NewStaticHandler(tmpDir, "/", []string{"index.html"}, false)
|
||
handler.SetTryFiles([]string{"$uri", "$uri.html", "/index.html"}, false, nil)
|
||
|
||
ctx := newTestContext(t, "/")
|
||
handler.Handle(ctx)
|
||
|
||
// 验证根路径请求正确回退到 /index.html
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
if got := string(ctx.Response.Body()); got != "root fallback" {
|
||
t.Errorf("内容 = %q, want %q", got, "root fallback")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_SetSymlinkCheck 测试 SetSymlinkCheck 方法
|
||
func TestStaticHandler_SetSymlinkCheck(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", nil, false)
|
||
|
||
if handler.symlinkCheck {
|
||
t.Error("初始 symlinkCheck 应为 false")
|
||
}
|
||
|
||
handler.SetSymlinkCheck(true)
|
||
if !handler.symlinkCheck {
|
||
t.Error("SetSymlinkCheck(true) 后 symlinkCheck 应为 true")
|
||
}
|
||
|
||
handler.SetSymlinkCheck(false)
|
||
if handler.symlinkCheck {
|
||
t.Error("SetSymlinkCheck(false) 后 symlinkCheck 应为 false")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_SetInternal 测试 SetInternal 方法
|
||
func TestStaticHandler_SetInternal(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", nil, false)
|
||
|
||
if handler.internal {
|
||
t.Error("初始 internal 应为 false")
|
||
}
|
||
|
||
handler.SetInternal(true)
|
||
if !handler.internal {
|
||
t.Error("SetInternal(true) 后 internal 应为 true")
|
||
}
|
||
|
||
handler.SetInternal(false)
|
||
if handler.internal {
|
||
t.Error("SetInternal(false) 后 internal 应为 false")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_SetCacheTTL 测试 SetCacheTTL 方法
|
||
func TestStaticHandler_SetCacheTTL(t *testing.T) {
|
||
handler := NewStaticHandler("/var/www", "/", nil, false)
|
||
|
||
if handler.cacheTTL != 0 {
|
||
t.Error("初始 cacheTTL 应为 0")
|
||
}
|
||
|
||
handler.SetCacheTTL(5 * time.Second)
|
||
if handler.cacheTTL != 5*time.Second {
|
||
t.Errorf("SetCacheTTL 后 cacheTTL = %v, want %v", handler.cacheTTL, 5*time.Second)
|
||
}
|
||
|
||
handler.SetCacheTTL(0)
|
||
if handler.cacheTTL != 0 {
|
||
t.Error("SetCacheTTL(0) 后 cacheTTL 应为 0")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_InternalRestriction 测试 internal 访问限制
|
||
func TestStaticHandler_InternalRestriction(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
content := "internal content"
|
||
if err := os.WriteFile(filepath.Join(tmpDir, "test.txt"), []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
handler := newTestHandler(t, tmpDir)
|
||
handler.SetInternal(true)
|
||
|
||
t.Run("外部请求返回 404", func(t *testing.T) {
|
||
ctx := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusNotFound {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusNotFound)
|
||
}
|
||
})
|
||
|
||
t.Run("内部重定向允许访问", func(t *testing.T) {
|
||
ctx := newTestContext(t, "/test.txt")
|
||
// 标记为内部重定向
|
||
ctx.SetUserValue("__internal_redirect__", "/test.txt")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestStaticHandler_ValidateSymlink 测试符号链接验证
|
||
func TestStaticHandler_ValidateSymlink(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建目标文件和目录
|
||
targetDir := filepath.Join(tmpDir, "target")
|
||
if err := os.MkdirAll(targetDir, 0o755); err != nil {
|
||
t.Fatalf("创建目标目录失败: %v", err)
|
||
}
|
||
targetFile := filepath.Join(targetDir, "secret.txt")
|
||
if err := os.WriteFile(targetFile, []byte("secret content"), 0o644); err != nil {
|
||
t.Fatalf("创建目标文件失败: %v", err)
|
||
}
|
||
|
||
// 创建允许的根目录
|
||
allowedDir := filepath.Join(tmpDir, "allowed")
|
||
if err := os.MkdirAll(allowedDir, 0o755); err != nil {
|
||
t.Fatalf("创建允许目录失败: %v", err)
|
||
}
|
||
|
||
t.Run("安全符号链接 - 在允许范围内", func(t *testing.T) {
|
||
// 在允许目录内创建符号链接
|
||
linkFile := filepath.Join(allowedDir, "link.txt")
|
||
allowedTarget := filepath.Join(allowedDir, "actual.txt")
|
||
if err := os.WriteFile(allowedTarget, []byte("allowed content"), 0o644); err != nil {
|
||
t.Fatalf("创建实际文件失败: %v", err)
|
||
}
|
||
if err := os.Symlink(allowedTarget, linkFile); err != nil {
|
||
t.Fatalf("创建符号链接失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(allowedDir, "/", nil, false)
|
||
handler.SetSymlinkCheck(true)
|
||
|
||
ctx := newTestContext(t, "/link.txt")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
})
|
||
|
||
t.Run("不安全符号链接 - 指向允许范围外", func(t *testing.T) {
|
||
// 创建指向允许目录外的符号链接
|
||
unsafeLink := filepath.Join(allowedDir, "unsafe.txt")
|
||
if err := os.Symlink(targetFile, unsafeLink); err != nil {
|
||
t.Fatalf("创建不安全符号链接失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(allowedDir, "/", nil, false)
|
||
handler.SetSymlinkCheck(true)
|
||
|
||
ctx := newTestContext(t, "/unsafe.txt")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusForbidden {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusForbidden)
|
||
}
|
||
})
|
||
|
||
t.Run("普通文件 - 非符号链接", func(t *testing.T) {
|
||
normalFile := filepath.Join(allowedDir, "normal.txt")
|
||
if err := os.WriteFile(normalFile, []byte("normal content"), 0o644); err != nil {
|
||
t.Fatalf("创建普通文件失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(allowedDir, "/", nil, false)
|
||
handler.SetSymlinkCheck(true)
|
||
|
||
ctx := newTestContext(t, "/normal.txt")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
})
|
||
|
||
t.Run("未启用符号链接检查", func(t *testing.T) {
|
||
// 创建指向允许目录外的符号链接
|
||
externalLink := filepath.Join(allowedDir, "external.txt")
|
||
if err := os.Symlink(targetFile, externalLink); err != nil {
|
||
t.Fatalf("创建外部符号链接失败: %v", err)
|
||
}
|
||
|
||
handler := NewStaticHandler(allowedDir, "/", nil, false)
|
||
// 不启用符号链接检查
|
||
|
||
ctx := newTestContext(t, "/external.txt")
|
||
handler.Handle(ctx)
|
||
|
||
// 未启用检查时，可以访问符号链接
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
})
|
||
}
|
||
|
||
// TestStaticHandler_ValidateSymlink_WithAlias 测试 alias 模式下的符号链接验证
|
||
func TestStaticHandler_ValidateSymlink_WithAlias(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建 alias 目录
|
||
aliasDir := filepath.Join(tmpDir, "alias")
|
||
if err := os.MkdirAll(aliasDir, 0o755); err != nil {
|
||
t.Fatalf("创建 alias 目录失败: %v", err)
|
||
}
|
||
|
||
// 在 alias 目录内创建文件和符号链接
|
||
actualFile := filepath.Join(aliasDir, "actual.txt")
|
||
if err := os.WriteFile(actualFile, []byte("actual content"), 0o644); err != nil {
|
||
t.Fatalf("创建实际文件失败: %v", err)
|
||
}
|
||
|
||
linkFile := filepath.Join(aliasDir, "link.txt")
|
||
if err := os.Symlink(actualFile, linkFile); err != nil {
|
||
t.Fatalf("创建符号链接失败: %v", err)
|
||
}
|
||
|
||
handler := &StaticHandler{
|
||
alias: aliasDir,
|
||
pathPrefix: "/static/",
|
||
pathPrefixLen: len("/static/"),
|
||
}
|
||
handler.SetSymlinkCheck(true)
|
||
|
||
ctx := newTestContext(t, "/static/link.txt")
|
||
handler.Handle(ctx)
|
||
|
||
if got := ctx.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_ValidateSymlink_NoRootOrAlias 测试无 root/alias 时符号链接验证
|
||
func TestStaticHandler_ValidateSymlink_NoRootOrAlias(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
|
||
// 创建文件和符号链接
|
||
targetFile := filepath.Join(tmpDir, "target.txt")
|
||
if err := os.WriteFile(targetFile, []byte("target"), 0o644); err != nil {
|
||
t.Fatalf("创建目标文件失败: %v", err)
|
||
}
|
||
|
||
linkFile := filepath.Join(tmpDir, "link.txt")
|
||
if err := os.Symlink(targetFile, linkFile); err != nil {
|
||
t.Fatalf("创建符号链接失败: %v", err)
|
||
}
|
||
|
||
// 创建无 root/alias 的处理器
|
||
handler := NewStaticHandler("", "/", nil, false)
|
||
handler.SetSymlinkCheck(true)
|
||
|
||
// 直接调用 validateSymlink
|
||
err := handler.validateSymlink(linkFile)
|
||
if err == nil {
|
||
t.Error("无 root/alias 时验证符号链接应返回错误")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_WithCacheTTL 测试带 TTL 的缓存处理
|
||
func TestStaticHandler_Handle_WithCacheTTL(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
content := "cached with ttl"
|
||
testFile := filepath.Join(tmpDir, "test.txt")
|
||
if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
// 创建带缓存的处理器
|
||
handler := newTestHandler(t, tmpDir)
|
||
handler.SetFileCache(cache.NewFileCache(100, 1024*1024, time.Hour))
|
||
handler.SetCacheTTL(5 * time.Second)
|
||
|
||
// 第一次请求，填充缓存
|
||
ctx1 := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx1)
|
||
|
||
if got := ctx1.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("第一次请求状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
// 第二次请求，应该命中缓存
|
||
ctx2 := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx2)
|
||
|
||
if got := ctx2.Response.StatusCode(); got != fasthttp.StatusOK {
|
||
t.Errorf("第二次请求状态码 = %d, want %d", got, fasthttp.StatusOK)
|
||
}
|
||
|
||
// 内容应该一致
|
||
if string(ctx1.Response.Body()) != string(ctx2.Response.Body()) {
|
||
t.Error("缓存内容不一致")
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_CacheTTLExpired 测试 TTL 过期后重新验证
|
||
func TestStaticHandler_Handle_CacheTTLExpired(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
content := "initial content"
|
||
testFile := filepath.Join(tmpDir, "test.txt")
|
||
if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
// 创建带缓存的处理器，TTL 设置很短
|
||
handler := newTestHandler(t, tmpDir)
|
||
handler.SetFileCache(cache.NewFileCache(100, 1024*1024, time.Hour))
|
||
handler.SetCacheTTL(100 * time.Millisecond)
|
||
|
||
// 第一次请求，填充缓存
|
||
ctx1 := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx1)
|
||
|
||
// 等待 TTL 过期
|
||
time.Sleep(150 * time.Millisecond)
|
||
|
||
// 修改文件
|
||
newContent := "updated content"
|
||
if err := os.WriteFile(testFile, []byte(newContent), 0o644); err != nil {
|
||
t.Fatalf("更新文件失败: %v", err)
|
||
}
|
||
|
||
// 第二次请求，TTL 过期后应该重新读取
|
||
ctx2 := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx2)
|
||
|
||
if got := string(ctx2.Response.Body()); got != newContent {
|
||
t.Errorf("TTL 过期后内容 = %q, want %q", got, newContent)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_Handle_CacheModTimeChanged 测试文件修改后缓存更新
|
||
func TestStaticHandler_Handle_CacheModTimeChanged(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
testFile := filepath.Join(tmpDir, "test.txt")
|
||
initialContent := "initial"
|
||
if err := os.WriteFile(testFile, []byte(initialContent), 0o644); err != nil {
|
||
t.Fatalf("创建测试文件失败: %v", err)
|
||
}
|
||
|
||
// 创建带缓存的处理器
|
||
handler := newTestHandler(t, tmpDir)
|
||
handler.SetFileCache(cache.NewFileCache(100, 1024*1024, time.Hour))
|
||
|
||
// 第一次请求，填充缓存
|
||
ctx1 := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx1)
|
||
|
||
// 修改文件
|
||
time.Sleep(10 * time.Millisecond) // 确保 ModTime 变化
|
||
newContent := "modified"
|
||
if err := os.WriteFile(testFile, []byte(newContent), 0o644); err != nil {
|
||
t.Fatalf("修改文件失败: %v", err)
|
||
}
|
||
|
||
// 第二次请求，应该检测到文件变化并更新缓存
|
||
ctx2 := newTestContext(t, "/test.txt")
|
||
handler.Handle(ctx2)
|
||
|
||
if got := string(ctx2.Response.Body()); got != newContent {
|
||
t.Errorf("修改后内容 = %q, want %q", got, newContent)
|
||
}
|
||
}
|
||
|
||
// TestStaticHandler_SetExpires 测试 SetExpires 方法。
|
||
func TestStaticHandler_SetExpires(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
handler := newTestHandler(t, tmpDir)
|
||
|
||
// 默认为空
|
||
if handler.expires != "" {
|
||
t.Errorf("默认 expires = %q, want empty", handler.expires)
|
||
}
|
||
|
||
// 设置 expires
|
||
handler.SetExpires("30d")
|
||
if handler.expires != "30d" {
|
||
t.Errorf("expires = %q, want 30d", handler.expires)
|
||
}
|
||
|
||
// 设置 off
|
||
handler.SetExpires("off")
|
||
if handler.expires != "off" {
|
||
t.Errorf("expires = %q, want off", handler.expires)
|
||
}
|
||
|
||
// 设置 max
|
||
handler.SetExpires("max")
|
||
if handler.expires != "max" {
|
||
t.Errorf("expires = %q, want max", handler.expires)
|
||
}
|
||
}
|
||
|
||
// TestSetCacheHeaders 测试 setCacheHeaders 方法。
|
||
func TestSetCacheHeaders(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
expires string
|
||
wantCacheCtrl string
|
||
wantExpiresSet bool // 是否设置 Expires 头
|
||
}{
|
||
{
|
||
name: "empty_expires",
|
||
expires: "",
|
||
wantCacheCtrl: "",
|
||
},
|
||
{
|
||
name: "off_expires",
|
||
expires: "off",
|
||
wantCacheCtrl: "",
|
||
},
|
||
{
|
||
name: "epoch_expires",
|
||
expires: "epoch",
|
||
wantCacheCtrl: "no-cache, no-store, must-revalidate",
|
||
wantExpiresSet: true,
|
||
},
|
||
{
|
||
name: "max_expires",
|
||
expires: "max",
|
||
wantCacheCtrl: "public, max-age=315360000, immutable",
|
||
wantExpiresSet: true,
|
||
},
|
||
{
|
||
name: "duration_expires",
|
||
expires: "1h",
|
||
wantCacheCtrl: "public, max-age=3600",
|
||
wantExpiresSet: true,
|
||
},
|
||
{
|
||
name: "complex_duration",
|
||
expires: "1d1h",
|
||
wantCacheCtrl: "public, max-age=90000",
|
||
wantExpiresSet: true,
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
tmpDir := t.TempDir()
|
||
handler := newTestHandler(t, tmpDir)
|
||
handler.SetExpires(tt.expires)
|
||
|
||
ctx := newTestContext(t, "/test.txt")
|
||
handler.setCacheHeaders(ctx)
|
||
|
||
cacheCtrl := string(ctx.Response.Header.Peek("Cache-Control"))
|
||
if tt.wantCacheCtrl == "" {
|
||
if cacheCtrl != "" {
|
||
t.Errorf("Cache-Control = %q, want empty", cacheCtrl)
|
||
}
|
||
} else {
|
||
if cacheCtrl != tt.wantCacheCtrl {
|
||
t.Errorf("Cache-Control = %q, want %q", cacheCtrl, tt.wantCacheCtrl)
|
||
}
|
||
}
|
||
|
||
expires := string(ctx.Response.Header.Peek("Expires"))
|
||
if tt.wantExpiresSet && expires == "" {
|
||
t.Error("Expected Expires header to be set")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestParseExpires 测试 parseExpires 函数。
|
||
func TestParseExpires(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
expires string
|
||
wantSecs int64
|
||
}{
|
||
{"empty", "", 0},
|
||
{"off", "off", 0},
|
||
{"max", "max", 315360000},
|
||
{"epoch", "epoch", -1},
|
||
{"seconds", "30s", 30},
|
||
{"minutes", "5m", 300},
|
||
{"hours", "2h", 7200},
|
||
{"days", "1d", 86400},
|
||
{"complex", "1d1h1m1s", 90061},
|
||
{"multiple_days", "30d", 2592000},
|
||
{"mixed", "7d12h", 648000},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := parseExpires(tt.expires)
|
||
if got != tt.wantSecs {
|
||
t.Errorf("parseExpires(%q) = %d, want %d", tt.expires, got, tt.wantSecs)
|
||
}
|
||
})
|
||
}
|
||
}
|