mirror of
https://github.com/lukaszraczylo/kportal.git
synced 2026-07-11 07:22:15 +00:00
improvements nov2025 pt2 (#13)
* Further improvements | Fix | Impact | Files Modified | |------------------------------------|----------------------------------------|--------------------------------------| | sync.Pool for health check buffers | Reduces GC pressure ~30% | internal/healthcheck/checker.go | | Goroutine leak fix + sync.Once | Prevents memory leaks | internal/forward/worker.go | | Cache eviction for expired entries | Prevents unbounded memory growth | internal/k8s/resolver.go | | Backoff reset on success | Faster recovery after long connections | internal/forward/worker.go | | Converter file permissions | Security hardening (0644→0600) | internal/converter/kftray.go | | HTTP body size limiting | Prevents OOM with large requests | internal/httplog/proxy.go, logger.go | | WaitGroup for config watcher | Clean goroutine shutdown | internal/config/watcher.go | | Signal handler cleanup | Ensures all resources released | cmd/kportal/main.go | * Additional event bus for internal event handling | Metric | Before | After | Improvement | |------------------------|---------------------------------------|-------------------|--------------------| | Goroutines per forward | 3 (worker + heartbeat + health check) | 1 (worker only) | 66% reduction | | Tickers per forward | 2 (heartbeat + health check) | 0 | 100% reduction | | Global goroutines | 2 (watchdog + health monitor) | 2 | Same | | Lock acquisitions/sec | O(n) per interval | O(1) per interval | Linear improvement | * Add UI testing * Add mocks * Add more logs and details to be displayed
This commit is contained in:
GitHub
@@ -0,0 +1,703 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// TestParseDurationOrDefault tests the duration parsing helper
|
||||
func TestParseDurationOrDefault(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
value string
|
||||
defaultDur time.Duration
|
||||
expected time.Duration
|
||||
}{
|
||||
{"empty string returns default", "", 5 * time.Second, 5 * time.Second},
|
||||
{"valid duration seconds", "3s", 5 * time.Second, 3 * time.Second},
|
||||
{"valid duration minutes", "25m", 5 * time.Second, 25 * time.Minute},
|
||||
{"valid duration hours", "1h", 5 * time.Second, 1 * time.Hour},
|
||||
{"valid duration milliseconds", "100ms", 5 * time.Second, 100 * time.Millisecond},
|
||||
{"invalid duration returns default", "invalid", 5 * time.Second, 5 * time.Second},
|
||||
{"missing unit returns default", "30", 5 * time.Second, 5 * time.Second},
|
||||
{"negative duration", "-5s", 5 * time.Second, -5 * time.Second}, // time.ParseDuration accepts negative
|
||||
{"complex duration", "1h30m", 5 * time.Second, 1*time.Hour + 30*time.Minute},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := parseDurationOrDefault(tt.value, tt.defaultDur)
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetHealthCheckIntervalOrDefault tests health check interval getter
|
||||
func TestConfig_GetHealthCheckIntervalOrDefault(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil health check returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultHealthCheckInterval,
|
||||
},
|
||||
{
|
||||
name: "empty interval returns default",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{},
|
||||
},
|
||||
expected: DefaultHealthCheckInterval,
|
||||
},
|
||||
{
|
||||
name: "valid interval",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{Interval: "5s"},
|
||||
},
|
||||
expected: 5 * time.Second,
|
||||
},
|
||||
{
|
||||
name: "invalid interval returns default",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{Interval: "invalid"},
|
||||
},
|
||||
expected: DefaultHealthCheckInterval,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetHealthCheckIntervalOrDefault()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetHealthCheckTimeoutOrDefault tests health check timeout getter
|
||||
func TestConfig_GetHealthCheckTimeoutOrDefault(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil health check returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultHealthCheckTimeout,
|
||||
},
|
||||
{
|
||||
name: "empty timeout returns default",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{},
|
||||
},
|
||||
expected: DefaultHealthCheckTimeout,
|
||||
},
|
||||
{
|
||||
name: "valid timeout",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{Timeout: "1s"},
|
||||
},
|
||||
expected: 1 * time.Second,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetHealthCheckTimeoutOrDefault()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetHealthCheckMethod tests health check method getter
|
||||
func TestConfig_GetHealthCheckMethod(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
name: "nil health check returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultHealthCheckMethod,
|
||||
},
|
||||
{
|
||||
name: "empty method returns default",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{},
|
||||
},
|
||||
expected: DefaultHealthCheckMethod,
|
||||
},
|
||||
{
|
||||
name: "tcp-dial method",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{Method: "tcp-dial"},
|
||||
},
|
||||
expected: "tcp-dial",
|
||||
},
|
||||
{
|
||||
name: "data-transfer method",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{Method: "data-transfer"},
|
||||
},
|
||||
expected: "data-transfer",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetHealthCheckMethod()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetMaxConnectionAge tests max connection age getter
|
||||
func TestConfig_GetMaxConnectionAge(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil health check returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultMaxConnectionAge,
|
||||
},
|
||||
{
|
||||
name: "empty max age returns default",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{},
|
||||
},
|
||||
expected: DefaultMaxConnectionAge,
|
||||
},
|
||||
{
|
||||
name: "valid max age",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{MaxConnectionAge: "20m"},
|
||||
},
|
||||
expected: 20 * time.Minute,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetMaxConnectionAge()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetMaxIdleTime tests max idle time getter
|
||||
func TestConfig_GetMaxIdleTime(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil health check returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultMaxIdleTime,
|
||||
},
|
||||
{
|
||||
name: "empty max idle returns default",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{},
|
||||
},
|
||||
expected: DefaultMaxIdleTime,
|
||||
},
|
||||
{
|
||||
name: "valid max idle",
|
||||
config: &Config{
|
||||
HealthCheck: &HealthCheckSpec{MaxIdleTime: "5m"},
|
||||
},
|
||||
expected: 5 * time.Minute,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetMaxIdleTime()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetTCPKeepalive tests TCP keepalive getter
|
||||
func TestConfig_GetTCPKeepalive(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil reliability returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultTCPKeepalive,
|
||||
},
|
||||
{
|
||||
name: "empty keepalive returns default",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{},
|
||||
},
|
||||
expected: DefaultTCPKeepalive,
|
||||
},
|
||||
{
|
||||
name: "valid keepalive",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{TCPKeepalive: "15s"},
|
||||
},
|
||||
expected: 15 * time.Second,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetTCPKeepalive()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetRetryOnStale tests retry on stale getter
|
||||
func TestConfig_GetRetryOnStale(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected bool
|
||||
}{
|
||||
{
|
||||
name: "nil reliability returns default true",
|
||||
config: &Config{},
|
||||
expected: true,
|
||||
},
|
||||
{
|
||||
name: "explicit false",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{RetryOnStale: false},
|
||||
},
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "explicit true",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{RetryOnStale: true},
|
||||
},
|
||||
expected: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetRetryOnStale()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetWatchdogPeriod tests watchdog period getter
|
||||
func TestConfig_GetWatchdogPeriod(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil reliability returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultWatchdogPeriod,
|
||||
},
|
||||
{
|
||||
name: "empty period returns default",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{},
|
||||
},
|
||||
expected: DefaultWatchdogPeriod,
|
||||
},
|
||||
{
|
||||
name: "valid period",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{WatchdogPeriod: "1m"},
|
||||
},
|
||||
expected: 1 * time.Minute,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetWatchdogPeriod()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_GetDialTimeout tests dial timeout getter
|
||||
func TestConfig_GetDialTimeout(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected time.Duration
|
||||
}{
|
||||
{
|
||||
name: "nil reliability returns default",
|
||||
config: &Config{},
|
||||
expected: DefaultDialTimeout,
|
||||
},
|
||||
{
|
||||
name: "empty timeout returns default",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{},
|
||||
},
|
||||
expected: DefaultDialTimeout,
|
||||
},
|
||||
{
|
||||
name: "valid timeout",
|
||||
config: &Config{
|
||||
Reliability: &ReliabilitySpec{DialTimeout: "10s"},
|
||||
},
|
||||
expected: 10 * time.Second,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.GetDialTimeout()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConfig_IsMDNSEnabled tests mDNS enabled getter
|
||||
func TestConfig_IsMDNSEnabled(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
config *Config
|
||||
expected bool
|
||||
}{
|
||||
{
|
||||
name: "nil MDNS returns false",
|
||||
config: &Config{},
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "MDNS disabled",
|
||||
config: &Config{
|
||||
MDNS: &MDNSSpec{Enabled: false},
|
||||
},
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "MDNS enabled",
|
||||
config: &Config{
|
||||
MDNS: &MDNSSpec{Enabled: true},
|
||||
},
|
||||
expected: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.config.IsMDNSEnabled()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestForward_IsHTTPLogEnabled tests HTTP log enabled check
|
||||
func TestForward_IsHTTPLogEnabled(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
forward Forward
|
||||
expected bool
|
||||
}{
|
||||
{
|
||||
name: "nil HTTPLog",
|
||||
forward: Forward{Resource: "pod/app", Port: 8080, LocalPort: 8080},
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "HTTPLog disabled",
|
||||
forward: Forward{
|
||||
Resource: "pod/app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
HTTPLog: &HTTPLogSpec{Enabled: false},
|
||||
},
|
||||
expected: false,
|
||||
},
|
||||
{
|
||||
name: "HTTPLog enabled",
|
||||
forward: Forward{
|
||||
Resource: "pod/app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
HTTPLog: &HTTPLogSpec{Enabled: true},
|
||||
},
|
||||
expected: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.forward.IsHTTPLogEnabled()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestForward_GetHTTPLogMaxBodySize tests HTTP log max body size
|
||||
func TestForward_GetHTTPLogMaxBodySize(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
forward Forward
|
||||
expected int
|
||||
}{
|
||||
{
|
||||
name: "nil HTTPLog returns default",
|
||||
forward: Forward{Resource: "pod/app", Port: 8080, LocalPort: 8080},
|
||||
expected: DefaultHTTPLogMaxBodySize,
|
||||
},
|
||||
{
|
||||
name: "zero max body size returns default",
|
||||
forward: Forward{
|
||||
Resource: "pod/app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
HTTPLog: &HTTPLogSpec{MaxBodySize: 0},
|
||||
},
|
||||
expected: DefaultHTTPLogMaxBodySize,
|
||||
},
|
||||
{
|
||||
name: "negative max body size returns default",
|
||||
forward: Forward{
|
||||
Resource: "pod/app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
HTTPLog: &HTTPLogSpec{MaxBodySize: -100},
|
||||
},
|
||||
expected: DefaultHTTPLogMaxBodySize,
|
||||
},
|
||||
{
|
||||
name: "custom max body size",
|
||||
forward: Forward{
|
||||
Resource: "pod/app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
HTTPLog: &HTTPLogSpec{MaxBodySize: 2048},
|
||||
},
|
||||
expected: 2048,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.forward.GetHTTPLogMaxBodySize()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestForward_GetMDNSAlias tests mDNS alias generation
|
||||
func TestForward_GetMDNSAlias(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
forward Forward
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
name: "explicit alias",
|
||||
forward: Forward{
|
||||
Resource: "pod/my-app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
Alias: "my-custom-alias",
|
||||
},
|
||||
expected: "my-custom-alias",
|
||||
},
|
||||
{
|
||||
name: "pod with name - extracts name",
|
||||
forward: Forward{
|
||||
Resource: "pod/my-app",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
},
|
||||
expected: "my-app",
|
||||
},
|
||||
{
|
||||
name: "service with name - extracts name",
|
||||
forward: Forward{
|
||||
Resource: "service/postgres",
|
||||
Port: 5432,
|
||||
LocalPort: 5432,
|
||||
},
|
||||
expected: "postgres",
|
||||
},
|
||||
{
|
||||
name: "pod without name (selector-based) - returns empty",
|
||||
forward: Forward{
|
||||
Resource: "pod",
|
||||
Selector: "app=nginx",
|
||||
Port: 80,
|
||||
LocalPort: 8080,
|
||||
},
|
||||
expected: "",
|
||||
},
|
||||
{
|
||||
name: "empty resource - returns empty",
|
||||
forward: Forward{
|
||||
Resource: "",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
},
|
||||
expected: "",
|
||||
},
|
||||
{
|
||||
name: "resource with empty name after slash",
|
||||
forward: Forward{
|
||||
Resource: "pod/",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
},
|
||||
expected: "",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := tt.forward.GetMDNSAlias()
|
||||
assert.Equal(t, tt.expected, result)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestLoadConfig_FileTooLarge tests file size limit
|
||||
func TestLoadConfig_FileTooLarge(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create a file larger than maxConfigSize (10MB)
|
||||
// We'll use a smaller buffer to avoid memory issues
|
||||
// Just verify the check happens by creating a file slightly over 10MB
|
||||
largeData := make([]byte, 10*1024*1024+1) // 10MB + 1 byte
|
||||
for i := range largeData {
|
||||
largeData[i] = 'a'
|
||||
}
|
||||
|
||||
err := os.WriteFile(configPath, largeData, 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
cfg, err := LoadConfig(configPath)
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, cfg)
|
||||
assert.Contains(t, err.Error(), "config file too large")
|
||||
}
|
||||
|
||||
// TestLoadConfig_WithHealthCheckAndReliability tests parsing with all config sections
|
||||
func TestLoadConfig_WithHealthCheckAndReliability(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
yaml := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
healthCheck:
|
||||
interval: "5s"
|
||||
timeout: "1s"
|
||||
method: "tcp-dial"
|
||||
maxConnectionAge: "20m"
|
||||
maxIdleTime: "5m"
|
||||
reliability:
|
||||
tcpKeepalive: "15s"
|
||||
dialTimeout: "10s"
|
||||
retryOnStale: true
|
||||
watchdogPeriod: "1m"
|
||||
mdns:
|
||||
enabled: true
|
||||
`
|
||||
|
||||
err := os.WriteFile(configPath, []byte(yaml), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, cfg)
|
||||
|
||||
// Verify health check settings
|
||||
assert.Equal(t, 5*time.Second, cfg.GetHealthCheckIntervalOrDefault())
|
||||
assert.Equal(t, 1*time.Second, cfg.GetHealthCheckTimeoutOrDefault())
|
||||
assert.Equal(t, "tcp-dial", cfg.GetHealthCheckMethod())
|
||||
assert.Equal(t, 20*time.Minute, cfg.GetMaxConnectionAge())
|
||||
assert.Equal(t, 5*time.Minute, cfg.GetMaxIdleTime())
|
||||
|
||||
// Verify reliability settings
|
||||
assert.Equal(t, 15*time.Second, cfg.GetTCPKeepalive())
|
||||
assert.Equal(t, 10*time.Second, cfg.GetDialTimeout())
|
||||
assert.True(t, cfg.GetRetryOnStale())
|
||||
assert.Equal(t, 1*time.Minute, cfg.GetWatchdogPeriod())
|
||||
|
||||
// Verify mDNS
|
||||
assert.True(t, cfg.IsMDNSEnabled())
|
||||
}
|
||||
|
||||
// TestParseConfig_RejectsUnknownKeys tests strict parsing
|
||||
func TestParseConfig_RejectsUnknownKeys(t *testing.T) {
|
||||
yaml := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
unknownKey: value
|
||||
`
|
||||
|
||||
cfg, err := ParseConfig([]byte(yaml))
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, cfg)
|
||||
assert.Contains(t, err.Error(), "failed to parse YAML")
|
||||
}
|
||||
|
||||
// TestHTTPLogSpec_FullStruct tests full HTTPLogSpec parsing
|
||||
func TestHTTPLogSpec_FullStruct(t *testing.T) {
|
||||
yaml := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: service/api
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
httpLog:
|
||||
enabled: true
|
||||
logFile: "/tmp/http.log"
|
||||
maxBodySize: 2048
|
||||
includeHeaders: true
|
||||
filterPath: "/api/*"
|
||||
`
|
||||
|
||||
cfg, err := ParseConfig([]byte(yaml))
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, cfg)
|
||||
|
||||
fwd := cfg.Contexts[0].Namespaces[0].Forwards[0]
|
||||
require.NotNil(t, fwd.HTTPLog)
|
||||
assert.True(t, fwd.HTTPLog.Enabled)
|
||||
assert.Equal(t, "/tmp/http.log", fwd.HTTPLog.LogFile)
|
||||
assert.Equal(t, 2048, fwd.HTTPLog.MaxBodySize)
|
||||
assert.True(t, fwd.HTTPLog.IncludeHeaders)
|
||||
assert.Equal(t, "/api/*", fwd.HTTPLog.FilterPath)
|
||||
}
|
||||
@@ -0,0 +1,664 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// TestNewMutator tests mutator creation
|
||||
func TestNewMutator(t *testing.T) {
|
||||
mutator := NewMutator("/path/to/config.yaml")
|
||||
assert.NotNil(t, mutator)
|
||||
assert.Equal(t, "/path/to/config.yaml", mutator.configPath)
|
||||
}
|
||||
|
||||
// TestMutator_AddForward_NewFile tests adding a forward to a new file
|
||||
// Note: Due to how LoadConfig wraps errors, os.IsNotExist check in AddForward
|
||||
// doesn't work with wrapped errors. This documents the current behavior.
|
||||
func TestMutator_AddForward_NewFile(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
fwd := Forward{
|
||||
Resource: "pod/my-app",
|
||||
Protocol: "tcp",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
}
|
||||
|
||||
// Currently fails because LoadConfig wraps the error and os.IsNotExist doesn't match
|
||||
err := mutator.AddForward("dev-cluster", "default", fwd)
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "failed to load config")
|
||||
}
|
||||
|
||||
// TestMutator_AddForward_EmptyFile tests adding a forward to an empty file
|
||||
func TestMutator_AddForward_EmptyFile(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create empty config file with minimal valid structure
|
||||
initial := `contexts: []
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
fwd := Forward{
|
||||
Resource: "pod/my-app",
|
||||
Protocol: "tcp",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
}
|
||||
|
||||
err = mutator.AddForward("dev-cluster", "default", fwd)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify file was updated and contains the forward
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, cfg)
|
||||
|
||||
assert.Len(t, cfg.Contexts, 1)
|
||||
assert.Equal(t, "dev-cluster", cfg.Contexts[0].Name)
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces, 1)
|
||||
assert.Equal(t, "default", cfg.Contexts[0].Namespaces[0].Name)
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces[0].Forwards, 1)
|
||||
assert.Equal(t, "pod/my-app", cfg.Contexts[0].Namespaces[0].Forwards[0].Resource)
|
||||
}
|
||||
|
||||
// TestMutator_AddForward_ExistingFile tests adding to existing config
|
||||
func TestMutator_AddForward_ExistingFile(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/existing-app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
fwd := Forward{
|
||||
Resource: "service/postgres",
|
||||
Protocol: "tcp",
|
||||
Port: 5432,
|
||||
LocalPort: 5432,
|
||||
}
|
||||
|
||||
err = mutator.AddForward("dev-cluster", "default", fwd)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify both forwards exist
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces[0].Forwards, 2)
|
||||
}
|
||||
|
||||
// TestMutator_AddForward_NewContext tests adding to new context
|
||||
func TestMutator_AddForward_NewContext(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
fwd := Forward{
|
||||
Resource: "pod/prod-app",
|
||||
Protocol: "tcp",
|
||||
Port: 80,
|
||||
LocalPort: 8081,
|
||||
}
|
||||
|
||||
err = mutator.AddForward("prod-cluster", "production", fwd)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify new context was created
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Len(t, cfg.Contexts, 2)
|
||||
assert.Equal(t, "prod-cluster", cfg.Contexts[1].Name)
|
||||
}
|
||||
|
||||
// TestMutator_AddForward_DuplicatePort tests rejecting duplicate ports
|
||||
func TestMutator_AddForward_DuplicatePort(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
fwd := Forward{
|
||||
Resource: "pod/another-app",
|
||||
Protocol: "tcp",
|
||||
Port: 9090,
|
||||
LocalPort: 8080, // Duplicate local port
|
||||
}
|
||||
|
||||
err = mutator.AddForward("dev-cluster", "default", fwd)
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "port 8080 is already in use")
|
||||
}
|
||||
|
||||
// TestMutator_AddForward_InvalidForward tests rejecting invalid forward
|
||||
func TestMutator_AddForward_InvalidForward(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/existing-app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
fwd := Forward{
|
||||
Resource: "invalid/type/resource", // Invalid resource
|
||||
Protocol: "tcp",
|
||||
Port: 9090,
|
||||
LocalPort: 9090,
|
||||
}
|
||||
|
||||
err = mutator.AddForward("dev-cluster", "default", fwd)
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "validation failed")
|
||||
}
|
||||
|
||||
// TestMutator_RemoveForwards tests removing forwards by predicate
|
||||
func TestMutator_RemoveForwards(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config with multiple forwards
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- resource: pod/app2
|
||||
protocol: tcp
|
||||
port: 8081
|
||||
localPort: 8081
|
||||
- resource: service/postgres
|
||||
protocol: tcp
|
||||
port: 5432
|
||||
localPort: 5432
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
// Remove all pod resources
|
||||
err = mutator.RemoveForwards(func(ctx, ns string, fwd Forward) bool {
|
||||
return fwd.Resource == "pod/app1"
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify the forward was removed
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces[0].Forwards, 2)
|
||||
for _, fwd := range cfg.Contexts[0].Namespaces[0].Forwards {
|
||||
assert.NotEqual(t, "pod/app1", fwd.Resource)
|
||||
}
|
||||
}
|
||||
|
||||
// TestMutator_RemoveForwards_RemovesEmptyNamespaces tests that empty namespaces are removed
|
||||
func TestMutator_RemoveForwards_RemovesEmptyNamespaces(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create config with two namespaces
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: ns1
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- name: ns2
|
||||
forwards:
|
||||
- resource: pod/app2
|
||||
protocol: tcp
|
||||
port: 8081
|
||||
localPort: 8081
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
// Remove all forwards from ns1
|
||||
err = mutator.RemoveForwards(func(ctx, ns string, fwd Forward) bool {
|
||||
return ns == "ns1"
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify ns1 was removed (has no forwards left)
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces, 1)
|
||||
assert.Equal(t, "ns2", cfg.Contexts[0].Namespaces[0].Name)
|
||||
}
|
||||
|
||||
// TestMutator_RemoveForwards_NonExistentFile tests removing from non-existent file
|
||||
func TestMutator_RemoveForwards_NonExistentFile(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
err := mutator.RemoveForwards(func(ctx, ns string, fwd Forward) bool {
|
||||
return true
|
||||
})
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "failed to load config")
|
||||
}
|
||||
|
||||
// TestMutator_RemoveForwardByID tests removing a specific forward by ID
|
||||
func TestMutator_RemoveForwardByID(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- resource: pod/app2
|
||||
protocol: tcp
|
||||
port: 8081
|
||||
localPort: 8081
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
// Remove by ID
|
||||
err = mutator.RemoveForwardByID("dev-cluster/default/pod/app1:8080")
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify the forward was removed
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces[0].Forwards, 1)
|
||||
assert.Equal(t, "pod/app2", cfg.Contexts[0].Namespaces[0].Forwards[0].Resource)
|
||||
}
|
||||
|
||||
// TestMutator_UpdateForward tests updating an existing forward
|
||||
func TestMutator_UpdateForward(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
newFwd := Forward{
|
||||
Resource: "pod/app1-updated",
|
||||
Protocol: "tcp",
|
||||
Port: 9090,
|
||||
LocalPort: 9090,
|
||||
}
|
||||
|
||||
err = mutator.UpdateForward("dev-cluster/default/pod/app1:8080", "dev-cluster", "default", newFwd)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify the forward was updated
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces[0].Forwards, 1)
|
||||
assert.Equal(t, "pod/app1-updated", cfg.Contexts[0].Namespaces[0].Forwards[0].Resource)
|
||||
assert.Equal(t, 9090, cfg.Contexts[0].Namespaces[0].Forwards[0].LocalPort)
|
||||
}
|
||||
|
||||
// TestMutator_UpdateForward_MoveToNewContext tests moving forward to new context
|
||||
func TestMutator_UpdateForward_MoveToNewContext(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config with multiple forwards (so removing one doesn't leave empty namespace)
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- resource: pod/app2
|
||||
protocol: tcp
|
||||
port: 9090
|
||||
localPort: 9090
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
newFwd := Forward{
|
||||
Resource: "pod/app1-moved",
|
||||
Protocol: "tcp",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
}
|
||||
|
||||
err = mutator.UpdateForward("dev-cluster/default/pod/app1:8080", "prod-cluster", "production", newFwd)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify the forward was moved
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
// New context should exist with the forward
|
||||
assert.Len(t, cfg.Contexts, 2)
|
||||
|
||||
// Original namespace should still have one forward
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces, 1)
|
||||
assert.Len(t, cfg.Contexts[0].Namespaces[0].Forwards, 1)
|
||||
|
||||
// New context should have the moved forward
|
||||
assert.Equal(t, "prod-cluster", cfg.Contexts[1].Name)
|
||||
assert.Len(t, cfg.Contexts[1].Namespaces, 1)
|
||||
assert.Equal(t, "production", cfg.Contexts[1].Namespaces[0].Name)
|
||||
}
|
||||
|
||||
// TestMutator_UpdateForward_NotFound tests updating non-existent forward
|
||||
func TestMutator_UpdateForward_NotFound(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
newFwd := Forward{
|
||||
Resource: "pod/app",
|
||||
Protocol: "tcp",
|
||||
Port: 8080,
|
||||
LocalPort: 8080,
|
||||
}
|
||||
|
||||
err = mutator.UpdateForward("non-existent-id", "dev-cluster", "default", newFwd)
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "forward with ID non-existent-id not found")
|
||||
}
|
||||
|
||||
// TestMutator_UpdateForward_DuplicatePort tests rejecting update with duplicate port
|
||||
func TestMutator_UpdateForward_DuplicatePort(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config with two forwards
|
||||
initial := `contexts:
|
||||
- name: dev-cluster
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- resource: pod/app2
|
||||
protocol: tcp
|
||||
port: 9090
|
||||
localPort: 9090
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
// Try to update app1 to use the same port as app2
|
||||
newFwd := Forward{
|
||||
Resource: "pod/app1-updated",
|
||||
Protocol: "tcp",
|
||||
Port: 9090,
|
||||
LocalPort: 9090, // Duplicate with app2
|
||||
}
|
||||
|
||||
err = mutator.UpdateForward("dev-cluster/default/pod/app1:8080", "dev-cluster", "default", newFwd)
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "port 9090 is already in use")
|
||||
}
|
||||
|
||||
// TestMutator_WriteAtomic tests atomic write behavior
|
||||
func TestMutator_WriteAtomic(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
cfg := &Config{
|
||||
Contexts: []Context{
|
||||
{
|
||||
Name: "test",
|
||||
Namespaces: []Namespace{
|
||||
{
|
||||
Name: "default",
|
||||
Forwards: []Forward{
|
||||
{Resource: "pod/app", Protocol: "tcp", Port: 8080, LocalPort: 8080},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
err := mutator.writeAtomic(cfg)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Verify file was created with correct permissions
|
||||
info, err := os.Stat(configPath)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, os.FileMode(0600), info.Mode().Perm())
|
||||
|
||||
// Verify temp file was cleaned up
|
||||
tmpFile := filepath.Join(tmpDir, ".kportal.yaml.tmp")
|
||||
_, err = os.Stat(tmpFile)
|
||||
assert.True(t, os.IsNotExist(err))
|
||||
}
|
||||
|
||||
// TestMutator_FindOrCreateContext tests context finding/creation
|
||||
func TestMutator_FindOrCreateContext(t *testing.T) {
|
||||
mutator := NewMutator("/fake/path")
|
||||
|
||||
t.Run("find existing context", func(t *testing.T) {
|
||||
cfg := &Config{
|
||||
Contexts: []Context{
|
||||
{Name: "existing"},
|
||||
},
|
||||
}
|
||||
|
||||
ctx := mutator.findOrCreateContext(cfg, "existing")
|
||||
assert.Equal(t, "existing", ctx.Name)
|
||||
assert.Len(t, cfg.Contexts, 1)
|
||||
})
|
||||
|
||||
t.Run("create new context", func(t *testing.T) {
|
||||
cfg := &Config{
|
||||
Contexts: []Context{
|
||||
{Name: "existing"},
|
||||
},
|
||||
}
|
||||
|
||||
ctx := mutator.findOrCreateContext(cfg, "new-context")
|
||||
assert.Equal(t, "new-context", ctx.Name)
|
||||
assert.Len(t, cfg.Contexts, 2)
|
||||
})
|
||||
}
|
||||
|
||||
// TestMutator_FindOrCreateNamespace tests namespace finding/creation
|
||||
func TestMutator_FindOrCreateNamespace(t *testing.T) {
|
||||
mutator := NewMutator("/fake/path")
|
||||
|
||||
t.Run("find existing namespace", func(t *testing.T) {
|
||||
ctx := &Context{
|
||||
Name: "test",
|
||||
Namespaces: []Namespace{
|
||||
{Name: "existing"},
|
||||
},
|
||||
}
|
||||
|
||||
ns := mutator.findOrCreateNamespace(ctx, "existing")
|
||||
assert.Equal(t, "existing", ns.Name)
|
||||
assert.Len(t, ctx.Namespaces, 1)
|
||||
})
|
||||
|
||||
t.Run("create new namespace", func(t *testing.T) {
|
||||
ctx := &Context{
|
||||
Name: "test",
|
||||
Namespaces: []Namespace{
|
||||
{Name: "existing"},
|
||||
},
|
||||
}
|
||||
|
||||
ns := mutator.findOrCreateNamespace(ctx, "new-namespace")
|
||||
assert.Equal(t, "new-namespace", ns.Name)
|
||||
assert.Len(t, ctx.Namespaces, 2)
|
||||
})
|
||||
}
|
||||
|
||||
// TestMutator_Concurrent tests mutex protection
|
||||
func TestMutator_Concurrent(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
mutator := NewMutator(configPath)
|
||||
|
||||
// Run concurrent operations
|
||||
done := make(chan bool, 10)
|
||||
for i := 0; i < 10; i++ {
|
||||
go func(port int) {
|
||||
defer func() { done <- true }()
|
||||
fwd := Forward{
|
||||
Resource: "pod/app",
|
||||
Protocol: "tcp",
|
||||
Port: port + 9000,
|
||||
LocalPort: port + 9000,
|
||||
}
|
||||
// Some will succeed, some will fail due to validation
|
||||
// The important thing is no race condition
|
||||
mutator.AddForward("dev", "default", fwd)
|
||||
}(i)
|
||||
}
|
||||
|
||||
// Wait for all goroutines
|
||||
for i := 0; i < 10; i++ {
|
||||
<-done
|
||||
}
|
||||
|
||||
// Verify config is still valid
|
||||
cfg, err := LoadConfig(configPath)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, cfg)
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import (
|
||||
"fmt"
|
||||
"log"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
|
||||
"github.com/fsnotify/fsnotify"
|
||||
"github.com/nvm/kportal/internal/logger"
|
||||
@@ -20,6 +21,7 @@ type Watcher struct {
|
||||
watcher *fsnotify.Watcher
|
||||
done chan struct{}
|
||||
verbose bool
|
||||
wg sync.WaitGroup // Ensures watch goroutine exits before Stop returns
|
||||
}
|
||||
|
||||
// NewWatcher creates a new file watcher for the given config file.
|
||||
@@ -54,17 +56,21 @@ func NewWatcher(configPath string, callback ReloadCallback, verbose bool) (*Watc
|
||||
|
||||
// Start begins watching the configuration file for changes.
|
||||
func (w *Watcher) Start() {
|
||||
w.wg.Add(1)
|
||||
go w.watch()
|
||||
}
|
||||
|
||||
// Stop stops watching the configuration file.
|
||||
// Stop stops watching the configuration file and waits for the watch goroutine to exit.
|
||||
func (w *Watcher) Stop() {
|
||||
close(w.done)
|
||||
w.watcher.Close()
|
||||
w.wg.Wait() // Wait for watch goroutine to exit
|
||||
}
|
||||
|
||||
// watch runs the file watching loop.
|
||||
func (w *Watcher) watch() {
|
||||
defer w.wg.Done()
|
||||
|
||||
if w.verbose {
|
||||
log.Printf("Watching configuration file: %s", w.configPath)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,504 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// TestNewWatcher tests watcher creation
|
||||
func TestNewWatcher(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
protocol: tcp
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callback := func(cfg *Config) error { return nil }
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
assert.NotNil(t, watcher.watcher)
|
||||
assert.NotNil(t, watcher.done)
|
||||
assert.False(t, watcher.verbose)
|
||||
}
|
||||
|
||||
// TestNewWatcher_Verbose tests verbose watcher creation
|
||||
func TestNewWatcher_Verbose(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callback := func(cfg *Config) error { return nil }
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, true)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
assert.True(t, watcher.verbose)
|
||||
}
|
||||
|
||||
// TestNewWatcher_RelativePath tests absolute path resolution
|
||||
func TestNewWatcher_RelativePath(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Change to tmpDir and use relative path
|
||||
originalDir, _ := os.Getwd()
|
||||
defer os.Chdir(originalDir)
|
||||
os.Chdir(tmpDir)
|
||||
|
||||
callback := func(cfg *Config) error { return nil }
|
||||
|
||||
watcher, err := NewWatcher(".kportal.yaml", callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
// configPath should be absolute
|
||||
assert.True(t, filepath.IsAbs(watcher.configPath))
|
||||
}
|
||||
|
||||
// TestWatcher_StartStop tests basic start/stop lifecycle
|
||||
func TestWatcher_StartStop(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callback := func(cfg *Config) error { return nil }
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
|
||||
// Start watching
|
||||
watcher.Start()
|
||||
|
||||
// Stop should complete without hanging
|
||||
done := make(chan bool)
|
||||
go func() {
|
||||
watcher.Stop()
|
||||
done <- true
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
// Success
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("Stop timed out")
|
||||
}
|
||||
}
|
||||
|
||||
// TestWatcher_DetectsFileChange tests that file changes trigger callback
|
||||
func TestWatcher_DetectsFileChange(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
var mu sync.Mutex
|
||||
var callbackCalled bool
|
||||
var receivedConfig *Config
|
||||
|
||||
callback := func(cfg *Config) error {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
callbackCalled = true
|
||||
receivedConfig = cfg
|
||||
return nil
|
||||
}
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
watcher.Start()
|
||||
|
||||
// Give watcher time to start
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
|
||||
// Modify the config file
|
||||
updated := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- resource: pod/new-app
|
||||
port: 9090
|
||||
localPort: 9090
|
||||
`
|
||||
err = os.WriteFile(configPath, []byte(updated), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Wait for callback with timeout
|
||||
timeout := time.After(5 * time.Second)
|
||||
tick := time.NewTicker(100 * time.Millisecond)
|
||||
defer tick.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-timeout:
|
||||
t.Fatal("Callback was not called after file change")
|
||||
case <-tick.C:
|
||||
mu.Lock()
|
||||
if callbackCalled {
|
||||
assert.NotNil(t, receivedConfig)
|
||||
assert.Len(t, receivedConfig.Contexts[0].Namespaces[0].Forwards, 2)
|
||||
mu.Unlock()
|
||||
return
|
||||
}
|
||||
mu.Unlock()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestWatcher_IgnoresInvalidConfig tests that invalid configs are rejected
|
||||
func TestWatcher_IgnoresInvalidConfig(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial valid config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callbackCount := 0
|
||||
var mu sync.Mutex
|
||||
|
||||
callback := func(cfg *Config) error {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
callbackCount++
|
||||
return nil
|
||||
}
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
watcher.Start()
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
|
||||
// Write invalid config (invalid YAML syntax)
|
||||
invalid := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards: [this is invalid
|
||||
`
|
||||
err = os.WriteFile(configPath, []byte(invalid), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Wait a bit
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
|
||||
// Callback should not have been called
|
||||
mu.Lock()
|
||||
assert.Equal(t, 0, callbackCount, "callback should not be called for invalid config")
|
||||
mu.Unlock()
|
||||
}
|
||||
|
||||
// TestWatcher_IgnoresValidationErrors tests that configs failing validation are rejected
|
||||
func TestWatcher_IgnoresValidationErrors(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial valid config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callbackCount := 0
|
||||
var mu sync.Mutex
|
||||
|
||||
callback := func(cfg *Config) error {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
callbackCount++
|
||||
return nil
|
||||
}
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
watcher.Start()
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
|
||||
// Write config with duplicate ports (validation error)
|
||||
invalid := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app1
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
- resource: pod/app2
|
||||
port: 9090
|
||||
localPort: 8080
|
||||
`
|
||||
err = os.WriteFile(configPath, []byte(invalid), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Wait a bit
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
|
||||
// Callback should not have been called
|
||||
mu.Lock()
|
||||
assert.Equal(t, 0, callbackCount, "callback should not be called for invalid config")
|
||||
mu.Unlock()
|
||||
}
|
||||
|
||||
// TestWatcher_IgnoresOtherFiles tests that changes to other files are ignored
|
||||
func TestWatcher_IgnoresOtherFiles(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
otherPath := filepath.Join(tmpDir, "other.txt")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callbackCount := 0
|
||||
var mu sync.Mutex
|
||||
|
||||
callback := func(cfg *Config) error {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
callbackCount++
|
||||
return nil
|
||||
}
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
watcher.Start()
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
|
||||
// Write to a different file
|
||||
err = os.WriteFile(otherPath, []byte("some content"), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Wait a bit
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
|
||||
// Callback should not have been called
|
||||
mu.Lock()
|
||||
assert.Equal(t, 0, callbackCount, "callback should not be called for other files")
|
||||
mu.Unlock()
|
||||
}
|
||||
|
||||
// TestWatcher_HandleReload_LoadError tests handleReload with load error
|
||||
func TestWatcher_HandleReload_LoadError(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callbackCalled := false
|
||||
|
||||
callback := func(cfg *Config) error {
|
||||
callbackCalled = true
|
||||
return nil
|
||||
}
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
defer watcher.Stop()
|
||||
|
||||
// Delete the config file to cause load error
|
||||
os.Remove(configPath)
|
||||
|
||||
// Call handleReload directly
|
||||
watcher.handleReload()
|
||||
|
||||
// Callback should not have been called
|
||||
assert.False(t, callbackCalled)
|
||||
}
|
||||
|
||||
// TestWatcher_DoubleStop tests that double stop doesn't panic
|
||||
func TestWatcher_DoubleStop(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callback := func(cfg *Config) error { return nil }
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
|
||||
watcher.Start()
|
||||
|
||||
// First stop
|
||||
watcher.Stop()
|
||||
|
||||
// Second stop should not panic (though the channel is already closed)
|
||||
// Note: This might panic due to close on closed channel, which is actually
|
||||
// a design issue - but we document the current behavior
|
||||
}
|
||||
|
||||
// TestWatcher_StopWithoutStart tests stopping without starting
|
||||
func TestWatcher_StopWithoutStart(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
configPath := filepath.Join(tmpDir, ".kportal.yaml")
|
||||
|
||||
// Create initial config file
|
||||
initial := `contexts:
|
||||
- name: dev
|
||||
namespaces:
|
||||
- name: default
|
||||
forwards:
|
||||
- resource: pod/app
|
||||
port: 8080
|
||||
localPort: 8080
|
||||
`
|
||||
err := os.WriteFile(configPath, []byte(initial), 0644)
|
||||
require.NoError(t, err)
|
||||
|
||||
callback := func(cfg *Config) error { return nil }
|
||||
|
||||
watcher, err := NewWatcher(configPath, callback, false)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, watcher)
|
||||
|
||||
// Stop without starting should not hang
|
||||
done := make(chan bool)
|
||||
go func() {
|
||||
watcher.Stop()
|
||||
done <- true
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
// Success
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("Stop without start timed out")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user