services -> domains

2026-07-10 20:46:22 +00:00
parent 3c99d26830
commit 79c0c32b98
45 changed files with 1447 additions and 1270 deletions
--- a/internal/domains/manager_test.go
+++ b/internal/domains/manager_test.go
@@ -0,0 +1,605 @@
+package domains
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRegisterAndGet(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	dom := Domain{
+		DomainName: "my-api.payne.io",
+		Source:     "wild-works",
+		Backend: Backend{
+			Address: "192.168.8.60:9001",
+			Type:    BackendHTTP,
+		},
+	}
+
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("Register failed: %v", err)
+	}
+
+	got, err := mgr.Get("my-api.payne.io")
+	if err != nil {
+		t.Fatalf("Get failed: %v", err)
+	}
+
+	if got.DomainName != "my-api.payne.io" {
+		t.Errorf("expected domain my-api.payne.io, got %s", got.DomainName)
+	}
+	if got.Backend.Address != "192.168.8.60:9001" {
+		t.Errorf("expected backend 192.168.8.60:9001, got %s", got.Backend.Address)
+	}
+	if got.TLS != TLSTerminate {
+		t.Errorf("expected TLS terminate (default for http), got %s", got.TLS)
+	}
+	if got.Source != "wild-works" {
+		t.Errorf("expected source wild-works, got %s", got.Source)
+	}
+}
+
+func TestRegisterTCPPassthrough(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	dom := Domain{
+		DomainName: "cloud.payne.io",
+		Source:     "wild-cloud",
+		Backend: Backend{
+			Address: "192.168.8.240:443",
+			Type:    BackendTCPPassthrough,
+		},
+		Subdomains: true,
+		Public:     true,
+	}
+
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("Register failed: %v", err)
+	}
+
+	got, err := mgr.Get("cloud.payne.io")
+	if err != nil {
+		t.Fatalf("Get failed: %v", err)
+	}
+
+	if got.TLS != TLSPassthrough {
+		t.Errorf("expected TLS passthrough for tcp-passthrough, got %s", got.TLS)
+	}
+	if !got.Subdomains {
+		t.Error("expected subdomains=true")
+	}
+	if !got.Public {
+		t.Error("expected public=true")
+	}
+}
+
+func TestListDomains(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	for _, domain := range []string{"a.example.com", "b.example.com", "c.example.com"} {
+		if err := mgr.Register(Domain{
+			DomainName: domain,
+			Source:     "test",
+			Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+		}); err != nil {
+			t.Fatalf("Register %s failed: %v", domain, err)
+		}
+	}
+
+	doms, err := mgr.List()
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+	if len(doms) != 3 {
+		t.Errorf("expected 3 domains, got %d", len(doms))
+	}
+}
+
+func TestDeregister(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	if err := mgr.Register(Domain{
+		DomainName: "temp.example.com",
+		Source:     "test",
+		Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+	}); err != nil {
+		t.Fatalf("Register failed: %v", err)
+	}
+
+	if err := mgr.Deregister("temp.example.com"); err != nil {
+		t.Fatalf("Deregister failed: %v", err)
+	}
+
+	if _, err := mgr.Get("temp.example.com"); err == nil {
+		t.Error("expected error after deregister, got nil")
+	}
+}
+
+func TestDeregisterBySource(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	// Register 3 domains from wild-cloud with same backend
+	for _, domain := range []string{"cloud.payne.io", "internal.cloud.payne.io", "payne.io"} {
+		mgr.Register(Domain{
+			DomainName: domain,
+			Source:     "wild-cloud",
+			Backend:    Backend{Address: "192.168.8.240:443", Type: BackendTCPPassthrough},
+			Public:     true,
+		})
+	}
+	// Register 1 domain from wild-works (different source)
+	mgr.Register(Domain{
+		DomainName: "my-api.payne.io",
+		Source:     "wild-works",
+		Backend:    Backend{Address: "127.0.0.1:9001", Type: BackendHTTP},
+	})
+
+	// Deregister all wild-cloud domains with backend 192.168.8.240:443
+	if err := mgr.DeregisterBySource("wild-cloud", "192.168.8.240:443"); err != nil {
+		t.Fatalf("DeregisterBySource failed: %v", err)
+	}
+
+	doms, _ := mgr.List()
+	if len(doms) != 1 {
+		t.Errorf("expected 1 remaining domain, got %d", len(doms))
+	}
+	if doms[0].DomainName != "my-api.payne.io" {
+		t.Errorf("expected wild-works domain to remain, got %s", doms[0].DomainName)
+	}
+}
+
+func TestUpdate(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	mgr.Register(Domain{
+		DomainName: "updatable.example.com",
+		Source:     "test",
+		Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+	})
+
+	if err := mgr.Update("updatable.example.com", map[string]any{
+		"public":     true,
+		"subdomains": true,
+	}); err != nil {
+		t.Fatalf("Update failed: %v", err)
+	}
+
+	got, _ := mgr.Get("updatable.example.com")
+	if !got.Public {
+		t.Error("expected public=true after update")
+	}
+	if !got.Subdomains {
+		t.Error("expected subdomains=true after update")
+	}
+}
+
+func TestRegisterValidation(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	// Missing domain
+	if err := mgr.Register(Domain{Backend: Backend{Address: "127.0.0.1:80", Type: BackendHTTP}}); err == nil {
+		t.Error("expected error for missing domain")
+	}
+
+	// Missing backend address
+	if err := mgr.Register(Domain{DomainName: "x.com", Backend: Backend{Type: BackendHTTP}}); err == nil {
+		t.Error("expected error for missing backend address")
+	}
+
+	// Missing backend type
+	if err := mgr.Register(Domain{DomainName: "x.com", Backend: Backend{Address: "127.0.0.1:80"}}); err == nil {
+		t.Error("expected error for missing backend type")
+	}
+}
+
+func TestDefaultSource(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	mgr.Register(Domain{
+		DomainName: "test.com",
+		Backend:    Backend{Address: "127.0.0.1:80", Type: BackendHTTP},
+	})
+
+	got, _ := mgr.Get("test.com")
+	if got.Source != "manual" {
+		t.Errorf("expected default source 'manual', got %s", got.Source)
+	}
+}
+
+func TestRegisterIdempotent(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	dom := Domain{
+		DomainName: "idempotent.example.com",
+		Source:     "test",
+		Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+	}
+
+	// Register twice with same domain
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("first Register failed: %v", err)
+	}
+
+	// Update the backend address on second registration
+	dom.Backend.Address = "127.0.0.1:9090"
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("second Register failed: %v", err)
+	}
+
+	// Should still have only one domain
+	doms, err := mgr.List()
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+	if len(doms) != 1 {
+		t.Errorf("expected 1 domain after idempotent register, got %d", len(doms))
+	}
+
+	// Should have the updated address
+	got, err := mgr.Get("idempotent.example.com")
+	if err != nil {
+		t.Fatalf("Get failed: %v", err)
+	}
+	if got.Backend.Address != "127.0.0.1:9090" {
+		t.Errorf("expected updated backend address 127.0.0.1:9090, got %s", got.Backend.Address)
+	}
+}
+
+func TestListNoDuplicates(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	domainNames := []string{
+		"alpha.example.com",
+		"beta.example.com",
+		"gamma.example.com",
+	}
+
+	// Register each domain
+	for _, name := range domainNames {
+		if err := mgr.Register(Domain{
+			DomainName: name,
+			Source:     "test",
+			Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+		}); err != nil {
+			t.Fatalf("Register %s failed: %v", name, err)
+		}
+	}
+
+	// Re-register one domain to verify no duplication
+	if err := mgr.Register(Domain{
+		DomainName: "beta.example.com",
+		Source:     "test",
+		Backend:    Backend{Address: "127.0.0.1:9090", Type: BackendHTTP},
+	}); err != nil {
+		t.Fatalf("Re-register beta failed: %v", err)
+	}
+
+	doms, err := mgr.List()
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+
+	if len(doms) != 3 {
+		t.Errorf("expected 3 unique domains, got %d", len(doms))
+	}
+
+	// Verify no duplicate domains
+	seen := make(map[string]bool)
+	for _, dom := range doms {
+		if seen[dom.DomainName] {
+			t.Errorf("duplicate domain in List(): %s", dom.DomainName)
+		}
+		seen[dom.DomainName] = true
+	}
+}
+
+func TestDomainToFilename(t *testing.T) {
+	tests := []struct {
+		domain   string
+		expected string
+	}{
+		{"cloud.payne.io", "cloud_payne_io.yaml"},
+		{"internal.cloud.payne.io", "internal_cloud_payne_io.yaml"},
+		{"payne.io", "payne_io.yaml"},
+		{"example.com", "example_com.yaml"},
+	}
+	for _, tt := range tests {
+		got := domainToFilename(tt.domain)
+		if got != tt.expected {
+			t.Errorf("domainToFilename(%q) = %q, want %q", tt.domain, got, tt.expected)
+		}
+	}
+}
+
+func TestGet_NotFound(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	_, err := mgr.Get("nonexistent.example.com")
+	if err == nil {
+		t.Error("expected error for non-existent domain, got nil")
+	}
+}
+
+func TestDeregister_NotFound(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	err := mgr.Deregister("nonexistent.example.com")
+	if err == nil {
+		t.Error("expected error when deregistering non-existent domain, got nil")
+	}
+}
+
+func TestDeregisterBySource_NoMatch(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	mgr.Register(Domain{
+		DomainName: "a.example.com",
+		Source:     "wild-cloud",
+		Backend:    Backend{Address: "10.0.0.1:443", Type: BackendTCPPassthrough},
+		Public:     true,
+	})
+	mgr.Register(Domain{
+		DomainName: "b.example.com",
+		Source:     "wild-works",
+		Backend:    Backend{Address: "10.0.0.2:8080", Type: BackendHTTP},
+	})
+
+	// Deregister with a source that doesn't match anything
+	err := mgr.DeregisterBySource("unknown-source", "10.0.0.99:443")
+	if err != nil {
+		t.Fatalf("DeregisterBySource with no matches should not error: %v", err)
+	}
+
+	// All domains should still be present
+	doms, _ := mgr.List()
+	if len(doms) != 2 {
+		t.Errorf("expected 2 domains after no-match deregister, got %d", len(doms))
+	}
+}
+
+func TestDeregisterBySource_PartialMatch(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	// Same source, different backends
+	mgr.Register(Domain{
+		DomainName: "a.example.com",
+		Source:     "wild-cloud",
+		Backend:    Backend{Address: "10.0.0.1:443", Type: BackendTCPPassthrough},
+		Public:     true,
+	})
+	mgr.Register(Domain{
+		DomainName: "b.example.com",
+		Source:     "wild-cloud",
+		Backend:    Backend{Address: "10.0.0.2:443", Type: BackendTCPPassthrough},
+		Public:     true,
+	})
+
+	// Deregister only the ones matching source AND backend
+	err := mgr.DeregisterBySource("wild-cloud", "10.0.0.1:443")
+	if err != nil {
+		t.Fatalf("DeregisterBySource failed: %v", err)
+	}
+
+	doms, _ := mgr.List()
+	if len(doms) != 1 {
+		t.Errorf("expected 1 remaining domain, got %d", len(doms))
+	}
+	if doms[0].DomainName != "b.example.com" {
+		t.Errorf("expected b.example.com to remain, got %s", doms[0].DomainName)
+	}
+}
+
+func TestUpdate_NotFound(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	err := mgr.Update("nonexistent.example.com", map[string]any{
+		"public": true,
+	})
+	if err == nil {
+		t.Error("expected error when updating non-existent domain, got nil")
+	}
+}
+
+func TestRegister_OverwritePreservesFile(t *testing.T) {
+	dir := t.TempDir()
+	mgr := NewManager(dir)
+
+	dom := Domain{
+		DomainName: "overwrite.example.com",
+		Source:     "test",
+		Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+	}
+
+	// Register first time
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("first Register failed: %v", err)
+	}
+
+	// Register again with different backend
+	dom.Backend.Address = "127.0.0.1:9090"
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("second Register failed: %v", err)
+	}
+
+	// File count should be exactly 1
+	entries, err := os.ReadDir(filepath.Join(dir, "domains"))
+	if err != nil {
+		t.Fatalf("ReadDir failed: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Errorf("expected 1 file after overwrite, got %d", len(entries))
+	}
+
+	// Value should be updated
+	got, _ := mgr.Get("overwrite.example.com")
+	if got.Backend.Address != "127.0.0.1:9090" {
+		t.Errorf("expected updated backend 127.0.0.1:9090, got %s", got.Backend.Address)
+	}
+}
+
+func TestList_EmptyDir(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	doms, err := mgr.List()
+	if err != nil {
+		t.Fatalf("List on empty dir should not error: %v", err)
+	}
+	if len(doms) != 0 {
+		t.Errorf("expected 0 domains from empty dir, got %d", len(doms))
+	}
+}
+
+func TestRegisterWithL7Fields(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	dom := Domain{
+		DomainName: "keila.cloud.payne.io",
+		Source:     "wild-cloud",
+		Routes: []Route{{
+			Paths: []string{"/.well-known/matrix", "/_matrix"},
+			Backend: Backend{
+				Address: "192.168.8.80:80",
+				Type:    BackendHTTP,
+			},
+			Headers: &HeaderConfig{
+				Response: map[string]string{
+					"Access-Control-Allow-Origin": "https://payne.io",
+				},
+				Request: map[string]string{
+					"X-Forwarded-Proto": "https",
+				},
+			},
+			IPAllow: []string{"10.0.0.0/8", "192.168.0.0/16"},
+		}},
+	}
+
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("Register failed: %v", err)
+	}
+
+	got, err := mgr.Get("keila.cloud.payne.io")
+	if err != nil {
+		t.Fatalf("Get failed: %v", err)
+	}
+
+	if len(got.Routes) != 1 {
+		t.Fatalf("expected 1 route, got %d", len(got.Routes))
+	}
+	r := got.Routes[0]
+	if len(r.Paths) != 2 || r.Paths[0] != "/.well-known/matrix" {
+		t.Errorf("expected 2 paths, got %v", r.Paths)
+	}
+	if r.Headers == nil {
+		t.Fatal("expected headers, got nil")
+	}
+	if r.Headers.Response["Access-Control-Allow-Origin"] != "https://payne.io" {
+		t.Errorf("expected response header, got %v", r.Headers.Response)
+	}
+	if r.Headers.Request["X-Forwarded-Proto"] != "https" {
+		t.Errorf("expected request header, got %v", r.Headers.Request)
+	}
+	if len(r.IPAllow) != 2 || r.IPAllow[0] != "10.0.0.0/8" {
+		t.Errorf("expected 2 ipAllow CIDRs, got %v", r.IPAllow)
+	}
+}
+
+func TestUpdateL7Fields(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	mgr.Register(Domain{
+		DomainName: "updatable.example.com",
+		Source:     "test",
+		Routes: []Route{{
+			Paths:   []string{"/api", "/webhook"},
+			Backend: Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+			IPAllow: []string{"10.0.0.0/8"},
+			Headers: &HeaderConfig{
+				Response: map[string]string{
+					"X-Custom": "value",
+				},
+			},
+		}},
+	})
+
+	got, _ := mgr.Get("updatable.example.com")
+	if len(got.Routes) != 1 {
+		t.Fatalf("expected 1 route, got %d", len(got.Routes))
+	}
+	r := got.Routes[0]
+	if len(r.Paths) != 2 || r.Paths[0] != "/api" {
+		t.Errorf("expected paths [/api /webhook], got %v", r.Paths)
+	}
+	if len(r.IPAllow) != 1 || r.IPAllow[0] != "10.0.0.0/8" {
+		t.Errorf("expected ipAllow [10.0.0.0/8], got %v", r.IPAllow)
+	}
+	if r.Headers == nil || r.Headers.Response["X-Custom"] != "value" {
+		t.Errorf("expected response header X-Custom=value, got %v", r.Headers)
+	}
+}
+
+func TestList_IgnoresNonYAML(t *testing.T) {
+	dir := t.TempDir()
+	mgr := NewManager(dir)
+
+	// Register one real domain
+	mgr.Register(Domain{
+		DomainName: "real.example.com",
+		Source:     "test",
+		Backend:    Backend{Address: "127.0.0.1:8080", Type: BackendHTTP},
+	})
+
+	// Create non-YAML files in the domains directory
+	domainsDir := filepath.Join(dir, "domains")
+	os.WriteFile(filepath.Join(domainsDir, "README.md"), []byte("# ignore me"), 0644)
+	os.WriteFile(filepath.Join(domainsDir, "notes.txt"), []byte("some notes"), 0644)
+	os.WriteFile(filepath.Join(domainsDir, ".gitkeep"), []byte(""), 0644)
+
+	doms, err := mgr.List()
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+	if len(doms) != 1 {
+		t.Errorf("expected 1 domain (ignoring non-YAML files), got %d", len(doms))
+	}
+	if doms[0].DomainName != "real.example.com" {
+		t.Errorf("expected real.example.com, got %s", doms[0].DomainName)
+	}
+}
+
+func TestRegisterDNSOnly(t *testing.T) {
+	mgr := NewManager(t.TempDir())
+
+	dom := Domain{
+		DomainName: "dev.payne.io",
+		Source:     "manual",
+		Backend: Backend{
+			Address: "192.168.8.222",
+			Type:    BackendDNSOnly,
+		},
+		Public: true,
+	}
+
+	if err := mgr.Register(dom); err != nil {
+		t.Fatalf("Register failed: %v", err)
+	}
+
+	got, err := mgr.Get("dev.payne.io")
+	if err != nil {
+		t.Fatalf("Get failed: %v", err)
+	}
+
+	if got.TLS != TLSNone {
+		t.Errorf("expected TLS none for dns-only, got %s", got.TLS)
+	}
+	if got.Backend.Type != BackendDNSOnly {
+		t.Errorf("expected backend type dns-only, got %s", got.Backend.Type)
+	}
+	if got.Backend.Address != "192.168.8.222" {
+		t.Errorf("expected address 192.168.8.222, got %s", got.Backend.Address)
+	}
+	if !got.Public {
+		t.Error("expected public=true")
+	}
+}