906 lines
22 KiB
Go
906 lines
22 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/wild-cloud/wild-central/daemon/internal/storage"
|
|
)
|
|
|
|
// Test: NewManager creates manager successfully
|
|
func TestNewManager(t *testing.T) {
|
|
m := NewManager()
|
|
if m == nil {
|
|
t.Fatal("NewManager returned nil")
|
|
}
|
|
if m.yq == nil {
|
|
t.Error("Manager.yq is nil")
|
|
}
|
|
}
|
|
|
|
// Test: EnsureInstanceConfig creates config file with proper structure
|
|
func TestEnsureInstanceConfig(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setupFunc func(t *testing.T, instancePath string)
|
|
wantErr bool
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "creates config when not exists",
|
|
setupFunc: nil,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "returns nil when config exists",
|
|
setupFunc: func(t *testing.T, instancePath string) {
|
|
configPath := filepath.Join(instancePath, "config.yaml")
|
|
content := `baseDomain: "test.local"
|
|
domain: "test"
|
|
internalDomain: "internal.test"
|
|
dhcpRange: ""
|
|
backup:
|
|
root: ""
|
|
nfs:
|
|
host: ""
|
|
mediaPath: ""
|
|
cluster:
|
|
name: ""
|
|
loadBalancerIp: ""
|
|
ipAddressPool: ""
|
|
hostnamePrefix: ""
|
|
certManager:
|
|
cloudflare:
|
|
domain: ""
|
|
zoneID: ""
|
|
externalDns:
|
|
ownerId: ""
|
|
nodes:
|
|
talos:
|
|
version: ""
|
|
schematicId: ""
|
|
control:
|
|
vip: ""
|
|
activeNodes: []
|
|
`
|
|
if err := storage.WriteFile(configPath, []byte(content), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "returns error when config is invalid yaml",
|
|
setupFunc: func(t *testing.T, instancePath string) {
|
|
configPath := filepath.Join(instancePath, "config.yaml")
|
|
content := `invalid: yaml: content: [[[`
|
|
if err := storage.WriteFile(configPath, []byte(content), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
},
|
|
wantErr: true,
|
|
errContains: "invalid config file",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
instancePath := t.TempDir()
|
|
m := NewManager()
|
|
|
|
if tt.setupFunc != nil {
|
|
tt.setupFunc(t, instancePath)
|
|
}
|
|
|
|
err := m.EnsureInstanceConfig(instancePath)
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
return
|
|
}
|
|
|
|
// Verify config file exists
|
|
configPath := filepath.Join(instancePath, "config.yaml")
|
|
if !storage.FileExists(configPath) {
|
|
t.Error("config file not created")
|
|
}
|
|
|
|
// Verify config is valid YAML
|
|
if err := m.ValidateConfig(configPath); err != nil {
|
|
t.Errorf("config validation failed: %v", err)
|
|
}
|
|
|
|
// Verify config has expected structure
|
|
content, err := storage.ReadFile(configPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read config: %v", err)
|
|
}
|
|
contentStr := string(content)
|
|
requiredFields := []string{"baseDomain:", "domain:", "cluster:", "backup:", "nfs:"}
|
|
for _, field := range requiredFields {
|
|
if !strings.Contains(contentStr, field) {
|
|
t.Errorf("config missing required field: %s", field)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: GetConfigValue retrieves values correctly
|
|
func TestGetConfigValue(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
configYAML string
|
|
key string
|
|
want string
|
|
wantErr bool
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "get simple string value",
|
|
configYAML: `baseDomain: "example.com"
|
|
domain: "test"
|
|
`,
|
|
key: "baseDomain",
|
|
want: "example.com",
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "get nested value with dot notation",
|
|
configYAML: `cluster:
|
|
name: "my-cluster"
|
|
nodes:
|
|
talos:
|
|
version: "v1.8.0"
|
|
`,
|
|
key: "cluster.nodes.talos.version",
|
|
want: "v1.8.0",
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "get empty string value",
|
|
configYAML: `baseDomain: ""
|
|
`,
|
|
key: "baseDomain",
|
|
want: "",
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "get non-existent key returns null",
|
|
configYAML: `baseDomain: "example.com"
|
|
`,
|
|
key: "nonexistent",
|
|
want: "null",
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "get from array",
|
|
configYAML: `cluster:
|
|
nodes:
|
|
activeNodes:
|
|
- "node1"
|
|
- "node2"
|
|
`,
|
|
key: "cluster.nodes.activeNodes.[0]",
|
|
want: "node1",
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
|
|
if err := storage.WriteFile(configPath, []byte(tt.configYAML), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
|
|
m := NewManager()
|
|
got, err := m.GetConfigValue(configPath, tt.key)
|
|
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
return
|
|
}
|
|
|
|
if got != tt.want {
|
|
t.Errorf("got %q, want %q", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: GetConfigValue error cases
|
|
func TestGetConfigValue_Errors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setupFunc func(t *testing.T) string
|
|
key string
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "non-existent file",
|
|
setupFunc: func(t *testing.T) string {
|
|
return filepath.Join(t.TempDir(), "nonexistent.yaml")
|
|
},
|
|
key: "baseDomain",
|
|
errContains: "config file not found",
|
|
},
|
|
{
|
|
name: "malformed yaml",
|
|
setupFunc: func(t *testing.T) string {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
content := `invalid: yaml: [[[`
|
|
if err := storage.WriteFile(configPath, []byte(content), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
return configPath
|
|
},
|
|
key: "baseDomain",
|
|
errContains: "getting config value",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
configPath := tt.setupFunc(t)
|
|
m := NewManager()
|
|
|
|
_, err := m.GetConfigValue(configPath, tt.key)
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: SetConfigValue sets values correctly
|
|
func TestSetConfigValue(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
initialYAML string
|
|
key string
|
|
value string
|
|
verifyFunc func(t *testing.T, configPath string)
|
|
}{
|
|
{
|
|
name: "set simple value",
|
|
initialYAML: `baseDomain: ""
|
|
domain: ""
|
|
`,
|
|
key: "baseDomain",
|
|
value: "example.com",
|
|
verifyFunc: func(t *testing.T, configPath string) {
|
|
m := NewManager()
|
|
got, err := m.GetConfigValue(configPath, "baseDomain")
|
|
if err != nil {
|
|
t.Fatalf("verify failed: %v", err)
|
|
}
|
|
if got != "example.com" {
|
|
t.Errorf("got %q, want %q", got, "example.com")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "set nested value",
|
|
initialYAML: `cluster:
|
|
name: ""
|
|
nodes:
|
|
talos:
|
|
version: ""
|
|
`,
|
|
key: "cluster.nodes.talos.version",
|
|
value: "v1.8.0",
|
|
verifyFunc: func(t *testing.T, configPath string) {
|
|
m := NewManager()
|
|
got, err := m.GetConfigValue(configPath, "cluster.nodes.talos.version")
|
|
if err != nil {
|
|
t.Fatalf("verify failed: %v", err)
|
|
}
|
|
if got != "v1.8.0" {
|
|
t.Errorf("got %q, want %q", got, "v1.8.0")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "update existing value",
|
|
initialYAML: `baseDomain: "old.com"
|
|
`,
|
|
key: "baseDomain",
|
|
value: "new.com",
|
|
verifyFunc: func(t *testing.T, configPath string) {
|
|
m := NewManager()
|
|
got, err := m.GetConfigValue(configPath, "baseDomain")
|
|
if err != nil {
|
|
t.Fatalf("verify failed: %v", err)
|
|
}
|
|
if got != "new.com" {
|
|
t.Errorf("got %q, want %q", got, "new.com")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "create new nested path",
|
|
initialYAML: `cluster: {}
|
|
`,
|
|
key: "cluster.newField",
|
|
value: "newValue",
|
|
verifyFunc: func(t *testing.T, configPath string) {
|
|
m := NewManager()
|
|
got, err := m.GetConfigValue(configPath, "cluster.newField")
|
|
if err != nil {
|
|
t.Fatalf("verify failed: %v", err)
|
|
}
|
|
if got != "newValue" {
|
|
t.Errorf("got %q, want %q", got, "newValue")
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "set value with special characters",
|
|
initialYAML: `baseDomain: ""
|
|
`,
|
|
key: "baseDomain",
|
|
value: `special"quotes'and\backslashes`,
|
|
verifyFunc: func(t *testing.T, configPath string) {
|
|
m := NewManager()
|
|
got, err := m.GetConfigValue(configPath, "baseDomain")
|
|
if err != nil {
|
|
t.Fatalf("verify failed: %v", err)
|
|
}
|
|
if got != `special"quotes'and\backslashes` {
|
|
t.Errorf("got %q, want %q", got, `special"quotes'and\backslashes`)
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
|
|
if err := storage.WriteFile(configPath, []byte(tt.initialYAML), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
|
|
m := NewManager()
|
|
if err := m.SetConfigValue(configPath, tt.key, tt.value); err != nil {
|
|
t.Errorf("SetConfigValue failed: %v", err)
|
|
return
|
|
}
|
|
|
|
// Verify the value was set correctly
|
|
tt.verifyFunc(t, configPath)
|
|
|
|
// Verify config is still valid YAML
|
|
if err := m.ValidateConfig(configPath); err != nil {
|
|
t.Errorf("config validation failed after set: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: SetConfigValue error cases
|
|
func TestSetConfigValue_Errors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setupFunc func(t *testing.T) string
|
|
key string
|
|
value string
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "non-existent file",
|
|
setupFunc: func(t *testing.T) string {
|
|
return filepath.Join(t.TempDir(), "nonexistent.yaml")
|
|
},
|
|
key: "baseDomain",
|
|
value: "example.com",
|
|
errContains: "config file not found",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
configPath := tt.setupFunc(t)
|
|
m := NewManager()
|
|
|
|
err := m.SetConfigValue(configPath, tt.key, tt.value)
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: SetConfigValue with concurrent access
|
|
func TestSetConfigValue_ConcurrentAccess(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
|
|
initialYAML := `counter: "0"
|
|
`
|
|
if err := storage.WriteFile(configPath, []byte(initialYAML), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
|
|
m := NewManager()
|
|
const numGoroutines = 10
|
|
|
|
var wg sync.WaitGroup
|
|
errors := make(chan error, numGoroutines)
|
|
|
|
// Launch multiple goroutines trying to write different values
|
|
for i := 0; i < numGoroutines; i++ {
|
|
wg.Add(1)
|
|
go func(val int) {
|
|
defer wg.Done()
|
|
key := "counter"
|
|
value := string(rune('0' + val))
|
|
if err := m.SetConfigValue(configPath, key, value); err != nil {
|
|
errors <- err
|
|
}
|
|
}(i)
|
|
}
|
|
|
|
wg.Wait()
|
|
close(errors)
|
|
|
|
// Check if any errors occurred
|
|
for err := range errors {
|
|
t.Errorf("concurrent write error: %v", err)
|
|
}
|
|
|
|
// Verify config is still valid after concurrent access
|
|
if err := m.ValidateConfig(configPath); err != nil {
|
|
t.Errorf("config validation failed after concurrent writes: %v", err)
|
|
}
|
|
|
|
// Verify we can read the value (should be one of the written values)
|
|
value, err := m.GetConfigValue(configPath, "counter")
|
|
if err != nil {
|
|
t.Errorf("failed to read value after concurrent writes: %v", err)
|
|
}
|
|
if value == "" || value == "null" {
|
|
t.Error("counter value is empty after concurrent writes")
|
|
}
|
|
}
|
|
|
|
// Test: EnsureConfigValue sets value only when not set
|
|
func TestEnsureConfigValue(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
initialYAML string
|
|
key string
|
|
value string
|
|
expectSet bool
|
|
}{
|
|
{
|
|
name: "sets value when empty string",
|
|
initialYAML: `baseDomain: ""
|
|
`,
|
|
key: "baseDomain",
|
|
value: "example.com",
|
|
expectSet: true,
|
|
},
|
|
{
|
|
name: "sets value when null",
|
|
initialYAML: `baseDomain: null
|
|
`,
|
|
key: "baseDomain",
|
|
value: "example.com",
|
|
expectSet: true,
|
|
},
|
|
{
|
|
name: "does not set value when already set",
|
|
initialYAML: `baseDomain: "existing.com"
|
|
`,
|
|
key: "baseDomain",
|
|
value: "new.com",
|
|
expectSet: false,
|
|
},
|
|
{
|
|
name: "sets value when key does not exist",
|
|
initialYAML: `domain: "test"
|
|
`,
|
|
key: "baseDomain",
|
|
value: "example.com",
|
|
expectSet: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
|
|
if err := storage.WriteFile(configPath, []byte(tt.initialYAML), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
|
|
m := NewManager()
|
|
|
|
// Get initial value
|
|
initialVal, _ := m.GetConfigValue(configPath, tt.key)
|
|
|
|
// Call EnsureConfigValue
|
|
if err := m.EnsureConfigValue(configPath, tt.key, tt.value); err != nil {
|
|
t.Errorf("EnsureConfigValue failed: %v", err)
|
|
return
|
|
}
|
|
|
|
// Get final value
|
|
finalVal, err := m.GetConfigValue(configPath, tt.key)
|
|
if err != nil {
|
|
t.Fatalf("GetConfigValue failed: %v", err)
|
|
}
|
|
|
|
if tt.expectSet {
|
|
if finalVal != tt.value {
|
|
t.Errorf("expected value to be set to %q, got %q", tt.value, finalVal)
|
|
}
|
|
} else {
|
|
if finalVal != initialVal {
|
|
t.Errorf("expected value to remain %q, got %q", initialVal, finalVal)
|
|
}
|
|
}
|
|
|
|
// Call EnsureConfigValue again - should be idempotent
|
|
if err := m.EnsureConfigValue(configPath, tt.key, "different.com"); err != nil {
|
|
t.Errorf("second EnsureConfigValue failed: %v", err)
|
|
return
|
|
}
|
|
|
|
// Value should not change on second call
|
|
secondVal, err := m.GetConfigValue(configPath, tt.key)
|
|
if err != nil {
|
|
t.Fatalf("GetConfigValue failed: %v", err)
|
|
}
|
|
if secondVal != finalVal {
|
|
t.Errorf("value changed on second ensure: %q -> %q", finalVal, secondVal)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: ValidateConfig validates YAML correctly
|
|
func TestValidateConfig(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
configYAML string
|
|
wantErr bool
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "valid yaml",
|
|
configYAML: `baseDomain: "example.com"
|
|
domain: "test"
|
|
cluster:
|
|
name: "my-cluster"
|
|
`,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "invalid yaml - bad indentation",
|
|
configYAML: `baseDomain: "example.com"\n domain: "test"`,
|
|
wantErr: true,
|
|
errContains: "yaml validation failed",
|
|
},
|
|
{
|
|
name: "invalid yaml - unclosed bracket",
|
|
configYAML: `cluster: { name: "test"`,
|
|
wantErr: true,
|
|
errContains: "yaml validation failed",
|
|
},
|
|
{
|
|
name: "empty file",
|
|
configYAML: "",
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
|
|
if err := storage.WriteFile(configPath, []byte(tt.configYAML), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
|
|
m := NewManager()
|
|
err := m.ValidateConfig(configPath)
|
|
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: ValidateConfig error cases
|
|
func TestValidateConfig_Errors(t *testing.T) {
|
|
t.Run("non-existent file", func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
configPath := filepath.Join(tempDir, "nonexistent.yaml")
|
|
|
|
m := NewManager()
|
|
err := m.ValidateConfig(configPath)
|
|
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if !strings.Contains(err.Error(), "config file not found") {
|
|
t.Errorf("error %q does not contain 'config file not found'", err.Error())
|
|
}
|
|
})
|
|
}
|
|
|
|
// Test: CopyConfig copies configuration correctly
|
|
func TestCopyConfig(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
srcYAML string
|
|
setupDst func(t *testing.T, dstPath string)
|
|
wantErr bool
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "copies config successfully",
|
|
srcYAML: `baseDomain: "example.com"
|
|
domain: "test"
|
|
cluster:
|
|
name: "my-cluster"
|
|
`,
|
|
setupDst: nil,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "creates destination directory",
|
|
srcYAML: `baseDomain: "example.com"`,
|
|
setupDst: nil,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "overwrites existing destination",
|
|
srcYAML: `baseDomain: "new.com"
|
|
`,
|
|
setupDst: func(t *testing.T, dstPath string) {
|
|
oldContent := `baseDomain: "old.com"`
|
|
if err := storage.WriteFile(dstPath, []byte(oldContent), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
srcPath := filepath.Join(tempDir, "source.yaml")
|
|
dstPath := filepath.Join(tempDir, "subdir", "dest.yaml")
|
|
|
|
// Create source file
|
|
if err := storage.WriteFile(srcPath, []byte(tt.srcYAML), 0644); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
|
|
// Setup destination if needed
|
|
if tt.setupDst != nil {
|
|
if err := storage.EnsureDir(filepath.Dir(dstPath), 0755); err != nil {
|
|
t.Fatalf("setup failed: %v", err)
|
|
}
|
|
tt.setupDst(t, dstPath)
|
|
}
|
|
|
|
m := NewManager()
|
|
err := m.CopyConfig(srcPath, dstPath)
|
|
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
return
|
|
}
|
|
|
|
// Verify destination file exists
|
|
if !storage.FileExists(dstPath) {
|
|
t.Error("destination file not created")
|
|
}
|
|
|
|
// Verify content matches source
|
|
srcContent, err := storage.ReadFile(srcPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read source: %v", err)
|
|
}
|
|
dstContent, err := storage.ReadFile(dstPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read destination: %v", err)
|
|
}
|
|
|
|
if string(srcContent) != string(dstContent) {
|
|
t.Error("destination content does not match source")
|
|
}
|
|
|
|
// Verify destination is valid YAML
|
|
if err := m.ValidateConfig(dstPath); err != nil {
|
|
t.Errorf("destination config validation failed: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: CopyConfig error cases
|
|
func TestCopyConfig_Errors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setupFunc func(t *testing.T, tempDir string) (srcPath, dstPath string)
|
|
errContains string
|
|
}{
|
|
{
|
|
name: "source file does not exist",
|
|
setupFunc: func(t *testing.T, tempDir string) (string, string) {
|
|
return filepath.Join(tempDir, "nonexistent.yaml"),
|
|
filepath.Join(tempDir, "dest.yaml")
|
|
},
|
|
errContains: "source config file not found",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
srcPath, dstPath := tt.setupFunc(t, tempDir)
|
|
|
|
m := NewManager()
|
|
err := m.CopyConfig(srcPath, dstPath)
|
|
|
|
if err == nil {
|
|
t.Error("expected error, got nil")
|
|
} else if !strings.Contains(err.Error(), tt.errContains) {
|
|
t.Errorf("error %q does not contain %q", err.Error(), tt.errContains)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Test: File permissions are preserved
|
|
func TestEnsureInstanceConfig_FilePermissions(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
m := NewManager()
|
|
|
|
if err := m.EnsureInstanceConfig(tempDir); err != nil {
|
|
t.Fatalf("EnsureInstanceConfig failed: %v", err)
|
|
}
|
|
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
info, err := os.Stat(configPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to stat config file: %v", err)
|
|
}
|
|
|
|
// Verify file has 0644 permissions
|
|
if info.Mode().Perm() != 0644 {
|
|
t.Errorf("expected permissions 0644, got %v", info.Mode().Perm())
|
|
}
|
|
}
|
|
|
|
// Test: Idempotent config creation
|
|
func TestEnsureInstanceConfig_Idempotent(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
m := NewManager()
|
|
|
|
// First call creates config
|
|
if err := m.EnsureInstanceConfig(tempDir); err != nil {
|
|
t.Fatalf("first EnsureInstanceConfig failed: %v", err)
|
|
}
|
|
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
firstContent, err := storage.ReadFile(configPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read config: %v", err)
|
|
}
|
|
|
|
// Second call should not modify config
|
|
if err := m.EnsureInstanceConfig(tempDir); err != nil {
|
|
t.Fatalf("second EnsureInstanceConfig failed: %v", err)
|
|
}
|
|
|
|
secondContent, err := storage.ReadFile(configPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read config: %v", err)
|
|
}
|
|
|
|
if string(firstContent) != string(secondContent) {
|
|
t.Error("config content changed on second call")
|
|
}
|
|
}
|
|
|
|
// Test: Config structure contains all required fields
|
|
func TestEnsureInstanceConfig_RequiredFields(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
m := NewManager()
|
|
|
|
if err := m.EnsureInstanceConfig(tempDir); err != nil {
|
|
t.Fatalf("EnsureInstanceConfig failed: %v", err)
|
|
}
|
|
|
|
configPath := filepath.Join(tempDir, "config.yaml")
|
|
content, err := storage.ReadFile(configPath)
|
|
if err != nil {
|
|
t.Fatalf("failed to read config: %v", err)
|
|
}
|
|
|
|
contentStr := string(content)
|
|
requiredFields := []string{
|
|
"baseDomain:",
|
|
"domain:",
|
|
"internalDomain:",
|
|
"dhcpRange:",
|
|
"backup:",
|
|
"nfs:",
|
|
"cluster:",
|
|
"loadBalancerIp:",
|
|
"ipAddressPool:",
|
|
"hostnamePrefix:",
|
|
"certManager:",
|
|
"externalDns:",
|
|
"nodes:",
|
|
"talos:",
|
|
"version:",
|
|
"schematicId:",
|
|
"control:",
|
|
"vip:",
|
|
"activeNodes:",
|
|
}
|
|
|
|
for _, field := range requiredFields {
|
|
if !strings.Contains(contentStr, field) {
|
|
t.Errorf("config missing required field: %s", field)
|
|
}
|
|
}
|
|
}
|