ImaGen/internal/config/config_test.go

package config

import (
	"os"
	"path/filepath"
	"testing"
)

func TestLoadAndValidate(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "imagen.yaml")
	if err := os.WriteFile(path, []byte(Sample), 0o644); err != nil {
		t.Fatalf("write sample: %v", err)
	}
	cfg, err := Load(path)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	if cfg.DefaultBackend != "flux-schnell-local" {
		t.Errorf("default = %q", cfg.DefaultBackend)
	}
	mock, ok := cfg.Backends["mock"]
	if !ok {
		t.Fatalf("mock backend missing")
	}
	if mock.Type != "mock" {
		t.Errorf("mock type = %q", mock.Type)
	}
	flux, ok := cfg.Backends["flux-schnell-local"]
	if !ok {
		t.Fatalf("flux backend missing")
	}
	if flux.Type != "comfyui" {
		t.Errorf("flux type = %q", flux.Type)
	}
	if flux.Raw["base_url"] != "http://mrock:8188" {
		t.Errorf("flux base_url = %v", flux.Raw["base_url"])
	}
	if flux.Raw["model"] != "flux1-schnell.safetensors" {
		t.Errorf("flux model = %v", flux.Raw["model"])
	}
}

func TestValidateRejectsUnknownDefault(t *testing.T) {
	c := &Config{
		DefaultBackend: "ghost",
		Backends:       map[string]BackendSpec{"real": {Type: "mock"}},
	}
	if err := c.Validate(); err == nil {
		t.Errorf("expected error for unknown default_backend")
	}
}

func TestValidateRejectsMissingType(t *testing.T) {
	c := &Config{
		Backends: map[string]BackendSpec{"x": {}},
	}
	if err := c.Validate(); err == nil {
		t.Errorf("expected error for missing type")
	}
}

func TestValidatePreviewMode(t *testing.T) {
	for _, mode := range []string{"", "auto", "on", "off"} {
		c := &Config{Output: OutputConfig{Preview: mode}}
		if err := c.Validate(); err != nil {
			t.Errorf("preview=%q: unexpected error %v", mode, err)
		}
	}
	bad := &Config{Output: OutputConfig{Preview: "yes"}}
	if err := bad.Validate(); err == nil {
		t.Errorf("expected error for invalid preview value")
	}
}

func TestValidateCloudSyncMode(t *testing.T) {
	for _, mode := range []string{"", "auto", "on", "off"} {
		c := &Config{Output: OutputConfig{CloudSync: mode}}
		if err := c.Validate(); err != nil {
			t.Errorf("cloud_sync=%q: unexpected error %v", mode, err)
		}
	}
	bad := &Config{Output: OutputConfig{CloudSync: "yes"}}
	if err := bad.Validate(); err == nil {
		t.Errorf("expected error for invalid cloud_sync value")
	}
}

func TestSampleParsesCloudSyncAuto(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "imagen.yaml")
	if err := os.WriteFile(path, []byte(Sample), 0o644); err != nil {
		t.Fatalf("write sample: %v", err)
	}
	cfg, err := Load(path)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	if cfg.Output.CloudSync != "auto" {
		t.Errorf("Output.CloudSync = %q, want auto", cfg.Output.CloudSync)
	}
	// owner_user_id is intentionally empty in the sample — operators fill
	// it in after looking up their auth.users.id.
	if cfg.OwnerUserID != "" {
		t.Errorf("Sample OwnerUserID should be empty, got %q", cfg.OwnerUserID)
	}
}

func TestSampleParsesPreviewAuto(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "imagen.yaml")
	if err := os.WriteFile(path, []byte(Sample), 0o644); err != nil {
		t.Fatalf("write sample: %v", err)
	}
	cfg, err := Load(path)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	if cfg.Output.Preview != "auto" {
		t.Errorf("Output.Preview = %q, want auto", cfg.Output.Preview)
	}
}

func TestExpandPath(t *testing.T) {
	home, _ := os.UserHomeDir()
	cases := map[string]string{
		"":           "",
		"/abs/path":  "/abs/path",
		"~":          home,
		"~/foo/bar":  filepath.Join(home, "foo/bar"),
	}
	for in, want := range cases {
		if got := ExpandPath(in); got != want {
			t.Errorf("ExpandPath(%q) = %q, want %q", in, got, want)
		}
	}
}