validate_test.go

package kployconfig

import (
	"errors"
	"strings"
	"testing"
)

func TestValidate_Project(t *testing.T) {
	tests := []struct {
		name    string
		project string
		wantOK  bool
	}{
		{"valid myapp", "myapp", true},
		{"valid 3-char minimum", "foo", true},
		{"valid 13-char maximum", "abcdefghijklm", true},
		{"empty", "", false},
		{"too short", "ab", false},
		{"too long", "abcdefghijklmn", false},
		{"uppercase", "Bafflebots", false},
		{"leading digit", "1myapp", false},
		{"leading dash", "-myapp", false},
		{"underscore", "baffle_bots", false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := Validate(&Config{Project: tt.project})
			if tt.wantOK && err != nil {
				t.Fatalf("expected ok, got: %v", err)
			}
			if !tt.wantOK && err == nil {
				t.Fatalf("expected validation error, got nil")
			}
		})
	}
}

func TestValidate_PreviewEnabled_RequiresAdminsTemplateIngress(t *testing.T) {
	cfg := &Config{
		Project: "myapp",
		Preview: &Preview{Enabled: true},
	}
	err := Validate(cfg)
	if err == nil {
		t.Fatal("expected validation error, got nil")
	}
	var verrs ValidationErrors
	if !errors.As(err, &verrs) {
		t.Fatalf("expected ValidationErrors, got %T", err)
	}
	got := err.Error()
	for _, want := range []string{"admins", "preview.template", "preview.ingress"} {
		if !strings.Contains(got, want) {
			t.Errorf("missing field %q in error: %s", want, got)
		}
	}
}

func TestValidate_AdminsEmailFormat(t *testing.T) {
	cfg := &Config{
		Project: "myapp",
		Admins:  []string{"valid@example.com", "not-an-email"},
		Preview: &Preview{
			Enabled:  true,
			Template: "development",
			Ingress: []IngressEntry{
				{Service: ServiceRef{Name: "app", Port: 3000}},
			},
		},
	}
	err := Validate(cfg)
	if err == nil {
		t.Fatal("expected validation error")
	}
	if !strings.Contains(err.Error(), "admins[1]") {
		t.Errorf("expected admins[1] in error path, got: %s", err.Error())
	}
}

func TestValidate_IngressPortRange(t *testing.T) {
	tests := []struct {
		name   string
		port   int
		wantOK bool
	}{
		{"valid 3000", 3000, true},
		{"valid 1", 1, true},
		{"valid 65535", 65535, true},
		{"zero", 0, false},
		{"negative", -1, false},
		{"too high", 65536, false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cfg := &Config{
				Project: "myapp",
				Admins:  []string{"a@b.co"},
				Preview: &Preview{
					Enabled:  true,
					Template: "development",
					Ingress: []IngressEntry{
						{Service: ServiceRef{Name: "app", Port: tt.port}},
					},
				},
			}
			err := Validate(cfg)
			if tt.wantOK && err != nil {
				t.Fatalf("expected ok, got: %v", err)
			}
			if !tt.wantOK && err == nil {
				t.Fatal("expected error")
			}
		})
	}
}

func TestValidate_ImageTagPattern_RequiresPlaceholder(t *testing.T) {
	cfg := &Config{
		Project: "myapp",
		Admins:  []string{"a@b.co"},
		Preview: &Preview{
			Enabled:         true,
			Template:        "development",
			ImageTagPattern: "static-tag",
			Ingress: []IngressEntry{
				{Service: ServiceRef{Name: "app", Port: 3000}},
			},
		},
	}
	err := Validate(cfg)
	if err == nil || !strings.Contains(err.Error(), "preview.imageTagPattern") {
		t.Fatalf("expected imageTagPattern error, got: %v", err)
	}

	cfg.Preview.ImageTagPattern = "pr-{number}-{sha7}"
	if err := Validate(cfg); err != nil {
		t.Fatalf("expected ok with placeholders, got: %v", err)
	}
}

func TestValidate_GeneratedSecrets_EnvVarFormat(t *testing.T) {
	cfg := &Config{
		Project: "myapp",
		Admins:  []string{"a@b.co"},
		Preview: &Preview{
			Enabled:          true,
			Template:         "development",
			Ingress:          []IngressEntry{{Service: ServiceRef{Name: "app", Port: 3000}}},
			GeneratedSecrets: []string{"VALID_NAME", "lowercase", "1LEADING_DIGIT"},
		},
	}
	err := Validate(cfg)
	if err == nil {
		t.Fatal("expected error")
	}
	got := err.Error()
	if !strings.Contains(got, "generatedSecrets[1]") || !strings.Contains(got, "generatedSecrets[2]") {
		t.Errorf("expected both bad entries flagged, got: %s", got)
	}
}

func TestValidate_HostnameTemplate_BadSyntax(t *testing.T) {
	cfg := &Config{
		Project:  "myapp",
		Hostname: &Hostname{Template: "{{ .App "},
	}
	err := Validate(cfg)
	if err == nil || !strings.Contains(err.Error(), "hostname.template") {
		t.Fatalf("expected hostname.template error, got: %v", err)
	}
}

func TestValidate_PreviewDisabled_RelaxesRequirements(t *testing.T) {
	cfg := &Config{
		Project: "myapp",
		Preview: &Preview{Enabled: false},
	}
	if err := Validate(cfg); err != nil {
		t.Fatalf("expected ok, got: %v", err)
	}
}

func TestValidate_NilConfig(t *testing.T) {
	if err := Validate(nil); err == nil {
		t.Fatal("expected error for nil config")
	}
}