xfy
9b8ce2a08a
Replace depth-only detection with path-based visited set tracking. Detects cycles immediately on first revisit instead of after 10 depth iterations. Supports diamond patterns (A->B->shared, A->C->shared) via backtracking. Add self-include and diamond tests. Document that only servers/stream/variables are merged in defaults.go.
765 lines
18 KiB
Go
765 lines
18 KiB
Go
// Package config 提供配置加载和管理的测试。
|
|
package config
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// TestLoad 测试从文件加载配置。
|
|
func TestLoad(t *testing.T) {
|
|
t.Run("有效配置文件", func(t *testing.T) {
|
|
// 创建临时配置文件
|
|
content := `
|
|
servers:
|
|
- listen: ":8080"
|
|
static:
|
|
- path: "/"
|
|
root: "/var/www"
|
|
index:
|
|
- "index.html"
|
|
logging:
|
|
access:
|
|
path: "/var/log/access.log"
|
|
format: "combined"
|
|
error:
|
|
path: "/var/log/error.log"
|
|
level: "info"
|
|
performance:
|
|
goroutine_pool:
|
|
enabled: true
|
|
max_workers: 100
|
|
file_cache:
|
|
max_entries: 1000
|
|
monitoring:
|
|
status:
|
|
path: "/status"
|
|
`
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "config.yaml")
|
|
if err := os.WriteFile(tmpFile, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("创建临时配置文件失败: %v", err)
|
|
}
|
|
|
|
cfg, err := Load(tmpFile)
|
|
if err != nil {
|
|
t.Fatalf("Load() 失败: %v", err)
|
|
}
|
|
|
|
if cfg.Servers[0].Listen != ":8080" {
|
|
t.Errorf("Servers[0].Listen = %q, want %q", cfg.Servers[0].Listen, ":8080")
|
|
}
|
|
if cfg.Servers[0].Static[0].Root != "/var/www" {
|
|
t.Errorf("Servers[0].Static.Root = %q, want %q", cfg.Servers[0].Static[0].Root, "/var/www")
|
|
}
|
|
if len(cfg.Servers[0].Static[0].Index) != 1 || cfg.Servers[0].Static[0].Index[0] != "index.html" {
|
|
t.Errorf("Servers[0].Static.Index = %v, want [index.html]", cfg.Servers[0].Static[0].Index)
|
|
}
|
|
})
|
|
|
|
t.Run("文件不存在", func(t *testing.T) {
|
|
_, err := Load("/nonexistent/path/config.yaml")
|
|
if err == nil {
|
|
t.Error("Load() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
|
|
t.Run("无效YAML", func(t *testing.T) {
|
|
content := `
|
|
server:
|
|
listen: ":8080"
|
|
static:
|
|
root: [invalid yaml structure
|
|
`
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "invalid.yaml")
|
|
if err := os.WriteFile(tmpFile, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("创建临时配置文件失败: %v", err)
|
|
}
|
|
|
|
_, err := Load(tmpFile)
|
|
if err == nil {
|
|
t.Error("Load() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
|
|
t.Run("缺少必填字段（无服务器配置）", func(t *testing.T) {
|
|
content := `
|
|
logging:
|
|
access:
|
|
path: "/var/log/access.log"
|
|
`
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "no_server.yaml")
|
|
if err := os.WriteFile(tmpFile, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("创建临时配置文件失败: %v", err)
|
|
}
|
|
|
|
_, err := Load(tmpFile)
|
|
if err == nil {
|
|
t.Error("Load() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
|
|
t.Run("多虚拟主机模式", func(t *testing.T) {
|
|
content := `
|
|
servers:
|
|
- listen: ":8080"
|
|
name: "server1"
|
|
- listen: ":8081"
|
|
name: "server2"
|
|
`
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "multi.yaml")
|
|
if err := os.WriteFile(tmpFile, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("创建临时配置文件失败: %v", err)
|
|
}
|
|
|
|
cfg, err := Load(tmpFile)
|
|
if err != nil {
|
|
t.Fatalf("Load() 失败: %v", err)
|
|
}
|
|
|
|
if len(cfg.Servers) != 2 {
|
|
t.Fatalf("len(Servers) = %d, want 2", len(cfg.Servers))
|
|
}
|
|
if cfg.Servers[0].Name != "server1" {
|
|
t.Errorf("Servers[0].Name = %q, want %q", cfg.Servers[0].Name, "server1")
|
|
}
|
|
if cfg.Servers[1].Name != "server2" {
|
|
t.Errorf("Servers[1].Name = %q, want %q", cfg.Servers[1].Name, "server2")
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestLoadFromString 测试从字符串加载配置。
|
|
func TestLoadFromString(t *testing.T) {
|
|
t.Run("有效字符串", func(t *testing.T) {
|
|
yamlStr := `
|
|
servers:
|
|
- listen: ":9090"
|
|
static:
|
|
- path: "/"
|
|
root: "/app/public"
|
|
`
|
|
cfg, err := LoadFromString(yamlStr)
|
|
if err != nil {
|
|
t.Fatalf("LoadFromString() 失败: %v", err)
|
|
}
|
|
|
|
if cfg.Servers[0].Listen != ":9090" {
|
|
t.Errorf("Servers[0].Listen = %q, want %q", cfg.Servers[0].Listen, ":9090")
|
|
}
|
|
if cfg.Servers[0].Static[0].Root != "/app/public" {
|
|
t.Errorf("Servers[0].Static.Root = %q, want %q", cfg.Servers[0].Static[0].Root, "/app/public")
|
|
}
|
|
})
|
|
|
|
t.Run("无效YAML", func(t *testing.T) {
|
|
yamlStr := `
|
|
servers:
|
|
- listen: ":8080"
|
|
broken: [unclosed
|
|
`
|
|
_, err := LoadFromString(yamlStr)
|
|
if err == nil {
|
|
t.Error("LoadFromString() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
|
|
t.Run("缺少必填字段", func(t *testing.T) {
|
|
yamlStr := `
|
|
logging:
|
|
access:
|
|
path: "/var/log/access.log"
|
|
`
|
|
_, err := LoadFromString(yamlStr)
|
|
if err == nil {
|
|
t.Error("LoadFromString() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
|
|
t.Run("空字符串", func(t *testing.T) {
|
|
_, err := LoadFromString("")
|
|
if err == nil {
|
|
t.Error("LoadFromString() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestSave 测试保存配置到文件。
|
|
func TestSave(t *testing.T) {
|
|
t.Run("正常保存", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{{
|
|
Listen: ":8080",
|
|
Static: []StaticConfig{{
|
|
Path: "/",
|
|
Root: "/var/www",
|
|
Index: []string{"index.html"},
|
|
}},
|
|
}},
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "saved_config.yaml")
|
|
|
|
if err := Save(cfg, tmpFile); err != nil {
|
|
t.Fatalf("Save() 失败: %v", err)
|
|
}
|
|
|
|
// 验证文件已创建并可重新加载
|
|
loaded, err := Load(tmpFile)
|
|
if err != nil {
|
|
t.Fatalf("重新加载配置失败: %v", err)
|
|
}
|
|
|
|
if loaded.Servers[0].Listen != cfg.Servers[0].Listen {
|
|
t.Errorf("loaded.Servers[0].Listen = %q, want %q", loaded.Servers[0].Listen, cfg.Servers[0].Listen)
|
|
}
|
|
if loaded.Servers[0].Static[0].Root != cfg.Servers[0].Static[0].Root {
|
|
t.Errorf("loaded.Servers[0].Static[0].Root = %q, want %q", loaded.Servers[0].Static[0].Root, cfg.Servers[0].Static[0].Root)
|
|
}
|
|
})
|
|
|
|
t.Run("无效路径", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{{
|
|
Listen: ":8080",
|
|
}},
|
|
}
|
|
|
|
err := Save(cfg, "/nonexistent/directory/config.yaml")
|
|
if err == nil {
|
|
t.Error("Save() 期望返回错误，但返回 nil")
|
|
}
|
|
})
|
|
|
|
t.Run("保存多虚拟主机配置", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{
|
|
{Listen: ":8080", Name: "server1"},
|
|
{Listen: ":8081", Name: "server2"},
|
|
},
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "multi.yaml")
|
|
|
|
if err := Save(cfg, tmpFile); err != nil {
|
|
t.Fatalf("Save() 失败: %v", err)
|
|
}
|
|
|
|
loaded, err := Load(tmpFile)
|
|
if err != nil {
|
|
t.Fatalf("重新加载配置失败: %v", err)
|
|
}
|
|
|
|
if len(loaded.Servers) != 2 {
|
|
t.Errorf("len(loaded.Servers) = %d, want 2", len(loaded.Servers))
|
|
}
|
|
})
|
|
|
|
t.Run("保存并加载完整配置", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{{
|
|
Listen: ":8443",
|
|
Name: "default",
|
|
Static: []StaticConfig{{
|
|
Path: "/",
|
|
Root: "/var/www/html",
|
|
Index: []string{"index.html", "index.htm"},
|
|
}},
|
|
Proxy: []ProxyConfig{
|
|
{
|
|
Path: "/api",
|
|
Targets: []ProxyTarget{
|
|
{URL: "http://backend1:8080", Weight: 1},
|
|
{URL: "http://backend2:8080", Weight: 2},
|
|
},
|
|
LoadBalance: "round_robin",
|
|
},
|
|
},
|
|
SSL: SSLConfig{
|
|
Cert: "/etc/ssl/cert.pem",
|
|
Key: "/etc/ssl/key.pem",
|
|
Protocols: []string{"TLSv1.2", "TLSv1.3"},
|
|
},
|
|
Security: SecurityConfig{
|
|
RateLimit: RateLimitConfig{
|
|
RequestRate: 100,
|
|
Burst: 200,
|
|
},
|
|
},
|
|
}},
|
|
Logging: LoggingConfig{
|
|
Access: AccessLogConfig{
|
|
Path: "/var/log/access.log",
|
|
Format: "combined",
|
|
},
|
|
Error: ErrorLogConfig{
|
|
Path: "/var/log/error.log",
|
|
Level: "warn",
|
|
},
|
|
},
|
|
Performance: PerformanceConfig{
|
|
GoroutinePool: GoroutinePoolConfig{
|
|
Enabled: true,
|
|
MaxWorkers: 1000,
|
|
MinWorkers: 10,
|
|
},
|
|
},
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
tmpFile := filepath.Join(tmpDir, "full.yaml")
|
|
|
|
if err := Save(cfg, tmpFile); err != nil {
|
|
t.Fatalf("Save() 失败: %v", err)
|
|
}
|
|
|
|
loaded, err := Load(tmpFile)
|
|
if err != nil {
|
|
t.Fatalf("重新加载配置失败: %v", err)
|
|
}
|
|
|
|
// 验证关键字段
|
|
if loaded.Servers[0].Listen != cfg.Servers[0].Listen {
|
|
t.Errorf("loaded.Servers[0].Listen = %q, want %q", loaded.Servers[0].Listen, cfg.Servers[0].Listen)
|
|
}
|
|
if len(loaded.Servers[0].Proxy) != 1 {
|
|
t.Errorf("len(loaded.Servers[0].Proxy) = %d, want 1", len(loaded.Servers[0].Proxy))
|
|
}
|
|
if loaded.Servers[0].Proxy[0].LoadBalance != "round_robin" {
|
|
t.Errorf("loaded.Servers[0].Proxy[0].LoadBalance = %q, want %q", loaded.Servers[0].Proxy[0].LoadBalance, "round_robin")
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestConfigMethods 测试 Config 结构体的方法。
|
|
func TestConfigMethods(t *testing.T) {
|
|
t.Run("HasServers_有服务器列表", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{
|
|
{Listen: ":8080"},
|
|
},
|
|
}
|
|
if !cfg.HasServers() {
|
|
t.Error("HasServers() = false, want true")
|
|
}
|
|
})
|
|
|
|
t.Run("HasServers_无服务器列表", func(t *testing.T) {
|
|
cfg := &Config{}
|
|
if cfg.HasServers() {
|
|
t.Error("HasServers() = true, want false")
|
|
}
|
|
})
|
|
|
|
t.Run("GetDefaultServerFromList_有默认服务器", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{
|
|
{Listen: ":8080", Name: "api"},
|
|
{Listen: ":8081", Name: "default", Default: true},
|
|
},
|
|
}
|
|
server := cfg.GetDefaultServerFromList()
|
|
if server == nil {
|
|
t.Fatal("GetDefaultServerFromList() = nil, want non-nil")
|
|
}
|
|
if server.Listen != ":8081" {
|
|
t.Errorf("server.Listen = %q, want %q", server.Listen, ":8081")
|
|
}
|
|
})
|
|
|
|
t.Run("GetDefaultServerFromList_无默认服务器", func(t *testing.T) {
|
|
cfg := &Config{
|
|
Servers: []ServerConfig{
|
|
{Listen: ":8080", Name: "api"},
|
|
},
|
|
}
|
|
server := cfg.GetDefaultServerFromList()
|
|
if server != nil {
|
|
t.Errorf("GetDefaultServerFromList() = %v, want nil", server)
|
|
}
|
|
})
|
|
|
|
t.Run("配置模式判断", func(t *testing.T) {
|
|
tests := []struct {
|
|
cfg *Config
|
|
name string
|
|
wantHasServers bool
|
|
}{
|
|
{
|
|
name: "仅多虚拟主机",
|
|
cfg: &Config{Servers: []ServerConfig{{Listen: ":8080"}}},
|
|
wantHasServers: true,
|
|
},
|
|
{
|
|
name: "混合模式",
|
|
cfg: &Config{
|
|
Servers: []ServerConfig{{Listen: ":8081"}},
|
|
},
|
|
wantHasServers: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := tt.cfg.HasServers(); got != tt.wantHasServers {
|
|
t.Errorf("HasServers() = %v, want %v", got, tt.wantHasServers)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestProxyBufferingConfig_ParseBuffers(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
buffers string
|
|
bufferSize int
|
|
wantCount int
|
|
wantSizeEach int
|
|
}{
|
|
{
|
|
name: "empty uses buffer_size",
|
|
buffers: "",
|
|
bufferSize: 4096,
|
|
wantCount: 1,
|
|
wantSizeEach: 4096,
|
|
},
|
|
{
|
|
name: "8 16k format",
|
|
buffers: "8 16k",
|
|
wantCount: 8,
|
|
wantSizeEach: 16 * 1024,
|
|
},
|
|
{
|
|
name: "4 4k format",
|
|
buffers: "4 4k",
|
|
wantCount: 4,
|
|
wantSizeEach: 4 * 1024,
|
|
},
|
|
{
|
|
name: "2 1m format",
|
|
buffers: "2 1m",
|
|
wantCount: 2,
|
|
wantSizeEach: 1024 * 1024,
|
|
},
|
|
{
|
|
name: "bytes without unit",
|
|
buffers: "4 8192",
|
|
wantCount: 4,
|
|
wantSizeEach: 8192,
|
|
},
|
|
{
|
|
name: "uppercase K",
|
|
buffers: "8 16K",
|
|
wantCount: 8,
|
|
wantSizeEach: 16 * 1024,
|
|
},
|
|
{
|
|
name: "invalid format",
|
|
buffers: "invalid",
|
|
wantCount: 0,
|
|
wantSizeEach: 0,
|
|
},
|
|
{
|
|
name: "missing size",
|
|
buffers: "8",
|
|
wantCount: 0,
|
|
wantSizeEach: 0,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := &ProxyBufferingConfig{
|
|
Buffers: tt.buffers,
|
|
BufferSize: tt.bufferSize,
|
|
}
|
|
cfg.ParseBuffers()
|
|
|
|
if cfg.BufferCount != tt.wantCount {
|
|
t.Errorf("BufferCount = %d, want %d", cfg.BufferCount, tt.wantCount)
|
|
}
|
|
if cfg.BufferSizeEach != tt.wantSizeEach {
|
|
t.Errorf("BufferSizeEach = %d, want %d", cfg.BufferSizeEach, tt.wantSizeEach)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoad_Include(t *testing.T) {
|
|
t.Run("append servers from include", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
mainCfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
name: main
|
|
include:
|
|
- path: "conf.d/*.yaml"
|
|
`
|
|
incCfg := `
|
|
servers:
|
|
- listen: ":9090"
|
|
name: included
|
|
`
|
|
confDir := filepath.Join(tmpDir, "conf.d")
|
|
if err := os.MkdirAll(confDir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(mainCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(confDir, "extra.yaml"), []byte(incCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cfg, err := Load(filepath.Join(tmpDir, "config.yaml"))
|
|
if err != nil {
|
|
t.Fatalf("Load() failed: %v", err)
|
|
}
|
|
|
|
if len(cfg.Servers) != 2 {
|
|
t.Fatalf("expected 2 servers, got %d", len(cfg.Servers))
|
|
}
|
|
if cfg.Servers[0].Name != "main" {
|
|
t.Errorf("Servers[0].Name = %q, want %q", cfg.Servers[0].Name, "main")
|
|
}
|
|
if cfg.Servers[1].Name != "included" {
|
|
t.Errorf("Servers[1].Name = %q, want %q", cfg.Servers[1].Name, "included")
|
|
}
|
|
})
|
|
|
|
t.Run("merge variables with main priority", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
mainCfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
variables:
|
|
set:
|
|
app: lolly
|
|
env: production
|
|
include:
|
|
- path: "extra.yaml"
|
|
`
|
|
incCfg := `
|
|
servers:
|
|
- listen: ":9090"
|
|
variables:
|
|
set:
|
|
app: other
|
|
debug: "true"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(mainCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "extra.yaml"), []byte(incCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cfg, err := Load(filepath.Join(tmpDir, "config.yaml"))
|
|
if err != nil {
|
|
t.Fatalf("Load() failed: %v", err)
|
|
}
|
|
|
|
if cfg.Variables.Set["app"] != "lolly" {
|
|
t.Errorf("app = %q, want %q (main should win)", cfg.Variables.Set["app"], "lolly")
|
|
}
|
|
if cfg.Variables.Set["debug"] != "true" {
|
|
t.Errorf("debug = %q, want %q (included should fill missing)", cfg.Variables.Set["debug"], "true")
|
|
}
|
|
if cfg.Variables.Set["env"] != "production" {
|
|
t.Errorf("env = %q, want %q", cfg.Variables.Set["env"], "production")
|
|
}
|
|
})
|
|
|
|
t.Run("no matches returns error", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
mainCfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
include:
|
|
- path: "nonexistent/*.yaml"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(mainCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err := Load(filepath.Join(tmpDir, "config.yaml"))
|
|
if err == nil {
|
|
t.Error("expected error for non-matching glob pattern")
|
|
}
|
|
})
|
|
|
|
t.Run("circular include detected immediately", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
cfg1 := `
|
|
servers:
|
|
- listen: ":8080"
|
|
include:
|
|
- path: "b.yaml"
|
|
`
|
|
cfg2 := `
|
|
servers:
|
|
- listen: ":9090"
|
|
include:
|
|
- path: "a.yaml"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "a.yaml"), []byte(cfg1), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "b.yaml"), []byte(cfg2), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err := Load(filepath.Join(tmpDir, "a.yaml"))
|
|
if err == nil {
|
|
t.Error("expected error for circular include")
|
|
}
|
|
if !strings.Contains(err.Error(), "循环引入") {
|
|
t.Errorf("error should mention circular include, got: %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("self include detected", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
cfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
include:
|
|
- path: "a.yaml"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "a.yaml"), []byte(cfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
_, err := Load(filepath.Join(tmpDir, "a.yaml"))
|
|
if err == nil {
|
|
t.Error("expected error for self include")
|
|
}
|
|
})
|
|
|
|
t.Run("diamond include works", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
mainCfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
include:
|
|
- path: "b.yaml"
|
|
- path: "c.yaml"
|
|
`
|
|
bCfg := `
|
|
servers:
|
|
- listen: ":9090"
|
|
include:
|
|
- path: "shared.yaml"
|
|
`
|
|
cCfg := `
|
|
servers:
|
|
- listen: ":9091"
|
|
include:
|
|
- path: "shared.yaml"
|
|
`
|
|
sharedCfg := `
|
|
variables:
|
|
set:
|
|
shared: value
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(mainCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "b.yaml"), []byte(bCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "c.yaml"), []byte(cCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "shared.yaml"), []byte(sharedCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cfg, err := Load(filepath.Join(tmpDir, "config.yaml"))
|
|
if err != nil {
|
|
t.Fatalf("diamond include should work: %v", err)
|
|
}
|
|
|
|
if len(cfg.Servers) != 3 {
|
|
t.Errorf("expected 3 servers, got %d", len(cfg.Servers))
|
|
}
|
|
if cfg.Variables.Set["shared"] != "value" {
|
|
t.Error("shared variable should be merged")
|
|
}
|
|
})
|
|
|
|
t.Run("empty include list is no-op", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
mainCfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(mainCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cfg, err := Load(filepath.Join(tmpDir, "config.yaml"))
|
|
if err != nil {
|
|
t.Fatalf("Load() failed: %v", err)
|
|
}
|
|
if len(cfg.Servers) != 1 {
|
|
t.Errorf("expected 1 server, got %d", len(cfg.Servers))
|
|
}
|
|
})
|
|
|
|
t.Run("append stream from include", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
mainCfg := `
|
|
servers:
|
|
- listen: ":8080"
|
|
stream:
|
|
- listen: ":5432"
|
|
protocol: tcp
|
|
upstream:
|
|
targets:
|
|
- addr: "127.0.0.1:9000"
|
|
include:
|
|
- path: "stream.yaml"
|
|
`
|
|
incCfg := `
|
|
stream:
|
|
- listen: ":5433"
|
|
protocol: udp
|
|
upstream:
|
|
targets:
|
|
- addr: "127.0.0.1:9001"
|
|
`
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(mainCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(tmpDir, "stream.yaml"), []byte(incCfg), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cfg, err := Load(filepath.Join(tmpDir, "config.yaml"))
|
|
if err != nil {
|
|
t.Fatalf("Load() failed: %v", err)
|
|
}
|
|
|
|
if len(cfg.Stream) != 2 {
|
|
t.Fatalf("expected 2 streams, got %d", len(cfg.Stream))
|
|
}
|
|
})
|
|
}
|