147 lines
3.4 KiB
Go
147 lines
3.4 KiB
Go
package config_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"git.eeqj.de/sneak/webhooker/pkg/config"
|
|
"github.com/spf13/afero"
|
|
)
|
|
|
|
// ExampleSetFs demonstrates how to use an in-memory filesystem for testing
|
|
func ExampleSetFs() {
|
|
// Create an in-memory filesystem
|
|
fs := afero.NewMemMapFs()
|
|
|
|
// Create a test configuration file
|
|
configYAML := `
|
|
environments:
|
|
test:
|
|
config:
|
|
baseURL: https://test.example.com
|
|
debugMode: true
|
|
secrets:
|
|
apiKey: test-key-12345
|
|
production:
|
|
config:
|
|
baseURL: https://api.example.com
|
|
debugMode: false
|
|
configDefaults:
|
|
appName: Test Application
|
|
timeout: 30
|
|
`
|
|
|
|
// Write the config to the in-memory filesystem
|
|
if err := afero.WriteFile(fs, "config.yaml", []byte(configYAML), 0644); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Use the in-memory filesystem
|
|
config.SetFs(fs)
|
|
config.SetEnvironment("test")
|
|
|
|
// Now all config operations use the in-memory filesystem
|
|
fmt.Printf("Base URL: %s\n", config.GetString("baseURL"))
|
|
fmt.Printf("Debug Mode: %v\n", config.GetBool("debugMode"))
|
|
fmt.Printf("App Name: %s\n", config.GetString("appName"))
|
|
|
|
// Output:
|
|
// Base URL: https://test.example.com
|
|
// Debug Mode: true
|
|
// App Name: Test Application
|
|
}
|
|
|
|
// TestWithAferoFilesystem shows how to test with different filesystem implementations
|
|
func TestWithAferoFilesystem(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setupFs func() afero.Fs
|
|
environment string
|
|
key string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "in-memory filesystem",
|
|
setupFs: func() afero.Fs {
|
|
fs := afero.NewMemMapFs()
|
|
config := `
|
|
environments:
|
|
dev:
|
|
config:
|
|
apiURL: http://localhost:8080
|
|
`
|
|
afero.WriteFile(fs, "config.yaml", []byte(config), 0644)
|
|
return fs
|
|
},
|
|
environment: "dev",
|
|
key: "apiURL",
|
|
expected: "http://localhost:8080",
|
|
},
|
|
{
|
|
name: "readonly filesystem",
|
|
setupFs: func() afero.Fs {
|
|
memFs := afero.NewMemMapFs()
|
|
config := `
|
|
environments:
|
|
staging:
|
|
config:
|
|
apiURL: https://staging.example.com
|
|
`
|
|
afero.WriteFile(memFs, "config.yaml", []byte(config), 0644)
|
|
// Wrap in a read-only filesystem
|
|
return afero.NewReadOnlyFs(memFs)
|
|
},
|
|
environment: "staging",
|
|
key: "apiURL",
|
|
expected: "https://staging.example.com",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Create a new manager for each test to ensure isolation
|
|
manager := config.NewManager()
|
|
manager.SetFs(tt.setupFs())
|
|
manager.SetEnvironment(tt.environment)
|
|
|
|
result := manager.Get(tt.key, "")
|
|
if result != tt.expected {
|
|
t.Errorf("Expected %s, got %v", tt.expected, result)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFileResolution shows how $FILE: resolution works with afero
|
|
func TestFileResolution(t *testing.T) {
|
|
// Create an in-memory filesystem
|
|
fs := afero.NewMemMapFs()
|
|
|
|
// Create a secret file
|
|
secretContent := "super-secret-api-key"
|
|
if err := afero.WriteFile(fs, "/secrets/api-key.txt", []byte(secretContent), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Create a config that references the file
|
|
configYAML := `
|
|
environments:
|
|
prod:
|
|
secrets:
|
|
apiKey: $FILE:/secrets/api-key.txt
|
|
`
|
|
if err := afero.WriteFile(fs, "config.yaml", []byte(configYAML), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Use the filesystem
|
|
config.SetFs(fs)
|
|
config.SetEnvironment("prod")
|
|
|
|
// Get the secret - it should resolve from the file
|
|
apiKey := config.GetSecretString("apiKey")
|
|
if apiKey != secretContent {
|
|
t.Errorf("Expected %s, got %s", secretContent, apiKey)
|
|
}
|
|
}
|