adding stuff

Author: ianhodge

internal/config/config.go

@@ -0,0 +1,91 @@
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+// FileConfig represents the top-level YAML configuration file.
+type FileConfig struct {
+	WorkerID string        `yaml:"worker_id"`
+	Cleanup  *bool         `yaml:"cleanup"`
+	Backend  BackendConfig `yaml:"backend"`
+}
+
+// BackendConfig contains the backend selection.
+type BackendConfig struct {
+	Docker *DockerConfig `yaml:"docker"`
+}
+
+// DockerConfig holds Docker-backend-specific configuration.
+type DockerConfig struct {
+	Volumes     []string   `yaml:"volumes"`
+	Environment []EnvEntry `yaml:"environment"`
+}
+
+// EnvEntry represents a single environment variable in the config file.
+// If Value is nil, the variable is inherited from the host process environment.
+type EnvEntry struct {
+	Name  string  `yaml:"name"`
+	Value *string `yaml:"value"`
+}
+
+// Load reads and validates a YAML config file.
+func Load(path string) (*FileConfig, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config file: %w", err)
+	}
+
+	var cfg FileConfig
+	decoder := yaml.NewDecoder(bytes.NewReader(data))
+	decoder.KnownFields(true)
+	if err := decoder.Decode(&cfg); err != nil {
+		return nil, fmt.Errorf("failed to parse config file: %w", err)
+	}
+
+	if err := cfg.validate(); err != nil {
+		return nil, fmt.Errorf("invalid config: %w", err)
+	}
+
+	return &cfg, nil
+}
+
+func (c *FileConfig) validate() error {
+	if c.Backend.Docker != nil {
+		if err := validateEnvEntries(c.Backend.Docker.Environment); err != nil {
+			return fmt.Errorf("docker.environment: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func validateEnvEntries(entries []EnvEntry) error {
+	for i, entry := range entries {
+		if entry.Name == "" {
+			return fmt.Errorf("entry %d: name is required", i)
+		}
+		if strings.ContainsAny(entry.Name, " \t") {
+			return fmt.Errorf("entry %d: name %q contains whitespace", i, entry.Name)
+		}
+	}
+	return nil
+}
+
+// ResolveEnv converts environment entries to a map, resolving host-inherited values.
+func ResolveEnv(entries []EnvEntry) map[string]string {
+	result := make(map[string]string, len(entries))
+	for _, entry := range entries {
+		if entry.Value != nil {
+			result[entry.Name] = *entry.Value
+		} else {
+			result[entry.Name] = os.Getenv(entry.Name)
+		}
+	}
+	return result
+}

internal/config/config_test.go

@@ -0,0 +1,205 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func writeTestConfig(t *testing.T, content string) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "config.yaml")
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatalf("failed to write test config: %v", err)
+	}
+	return path
+}
+
+func TestLoadValidDockerConfig(t *testing.T) {
+	path := writeTestConfig(t, `
+worker_id: "my-worker"
+cleanup: false
+backend:
+  docker:
+    volumes:
+      - "/data:/data:ro"
+      - "/cache:/cache"
+    environment:
+      - name: FOO
+        value: "bar"
+      - name: BAZ
+        value: "qux"
+`)
+
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if cfg.WorkerID != "my-worker" {
+		t.Errorf("worker_id = %q, want %q", cfg.WorkerID, "my-worker")
+	}
+	if cfg.Cleanup == nil || *cfg.Cleanup != false {
+		t.Errorf("cleanup = %v, want false", cfg.Cleanup)
+	}
+	if cfg.Backend.Docker == nil {
+		t.Fatal("expected docker backend to be set")
+	}
+	if len(cfg.Backend.Docker.Volumes) != 2 {
+		t.Errorf("volumes count = %d, want 2", len(cfg.Backend.Docker.Volumes))
+	}
+	if len(cfg.Backend.Docker.Environment) != 2 {
+		t.Errorf("environment count = %d, want 2", len(cfg.Backend.Docker.Environment))
+	}
+}
+
+func TestLoadMinimalConfig(t *testing.T) {
+	path := writeTestConfig(t, `
+worker_id: "minimal"
+`)
+
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if cfg.WorkerID != "minimal" {
+		t.Errorf("worker_id = %q, want %q", cfg.WorkerID, "minimal")
+	}
+	if cfg.Cleanup != nil {
+		t.Errorf("cleanup should be nil when not specified, got %v", *cfg.Cleanup)
+	}
+	if cfg.Backend.Docker != nil {
+		t.Error("docker backend should be nil when not specified")
+	}
+}
+
+func TestLoadCleanupDefaultTrue(t *testing.T) {
+	path := writeTestConfig(t, `
+worker_id: "test"
+cleanup: true
+`)
+
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if cfg.Cleanup == nil || *cfg.Cleanup != true {
+		t.Errorf("cleanup = %v, want true", cfg.Cleanup)
+	}
+}
+
+func TestLoadInvalidYAML(t *testing.T) {
+	path := writeTestConfig(t, `
+worker_id: "test"
+  bad_indent: true
+`)
+
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("expected error for invalid YAML")
+	}
+}
+
+func TestLoadUnknownField(t *testing.T) {
+	path := writeTestConfig(t, `
+worker_id: "test"
+unknown_field: "value"
+`)
+
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("expected error for unknown field")
+	}
+}
+
+func TestLoadEmptyEnvName(t *testing.T) {
+	path := writeTestConfig(t, `
+backend:
+  docker:
+    environment:
+      - name: ""
+        value: "bar"
+`)
+
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("expected error for empty env name")
+	}
+}
+
+func TestLoadEnvNameWithWhitespace(t *testing.T) {
+	path := writeTestConfig(t, `
+backend:
+  docker:
+    environment:
+      - name: "MY VAR"
+        value: "bar"
+`)
+
+	_, err := Load(path)
+	if err == nil {
+		t.Fatal("expected error for env name with whitespace")
+	}
+}
+
+func TestLoadEnvInheritFromHost(t *testing.T) {
+	path := writeTestConfig(t, `
+backend:
+  docker:
+    environment:
+      - name: MY_HOST_VAR
+`)
+
+	cfg, err := Load(path)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	env := cfg.Backend.Docker.Environment[0]
+	if env.Name != "MY_HOST_VAR" {
+		t.Errorf("name = %q, want %q", env.Name, "MY_HOST_VAR")
+	}
+	if env.Value != nil {
+		t.Errorf("value should be nil for host-inherited var, got %q", *env.Value)
+	}
+}
+
+func TestResolveEnv(t *testing.T) {
+	explicit := "explicit_value"
+	entries := []EnvEntry{
+		{Name: "EXPLICIT", Value: &explicit},
+		{Name: "FROM_HOST"},
+	}
+
+	t.Setenv("FROM_HOST", "host_value")
+
+	result := ResolveEnv(entries)
+
+	if result["EXPLICIT"] != "explicit_value" {
+		t.Errorf("EXPLICIT = %q, want %q", result["EXPLICIT"], "explicit_value")
+	}
+	if result["FROM_HOST"] != "host_value" {
+		t.Errorf("FROM_HOST = %q, want %q", result["FROM_HOST"], "host_value")
+	}
+}
+
+func TestResolveEnvMissingHostVar(t *testing.T) {
+	entries := []EnvEntry{
+		{Name: "NONEXISTENT_VAR_12345"},
+	}
+
+	result := ResolveEnv(entries)
+
+	if result["NONEXISTENT_VAR_12345"] != "" {
+		t.Errorf("expected empty string for missing host var, got %q", result["NONEXISTENT_VAR_12345"])
+	}
+}
+
+func TestLoadFileNotFound(t *testing.T) {
+	_, err := Load("/nonexistent/path/config.yaml")
+	if err == nil {
+		t.Fatal("expected error for missing file")
+	}
+}