test(daemon): OnContainerStart/Die lifecycle, state management, teardown

Author: alysnnix

internal/daemon/daemon_test.go

@@ -0,0 +1,248 @@
+package daemon
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/alysnnix/devproxy/internal/dns"
+	"github.com/alysnnix/devproxy/internal/forwarder"
+	"github.com/alysnnix/devproxy/internal/ipman"
+	"github.com/alysnnix/devproxy/internal/state"
+	"github.com/alysnnix/devproxy/internal/watcher"
+)
+
+// newTestDaemon creates a Daemon suitable for unit testing.
+// It uses in-memory state (no persistence directory), a real IPManager,
+// and a DNS server bound to a random port on 127.0.0.1.
+func newTestDaemon(t *testing.T) *Daemon {
+	t.Helper()
+
+	s := state.New("")
+	im := ipman.New(s)
+	dnsServer := dns.New("127.0.0.1:0")
+
+	go dnsServer.ListenAndServe()
+	// Give the DNS server a moment to bind.
+	time.Sleep(50 * time.Millisecond)
+
+	t.Cleanup(func() {
+		dnsServer.Shutdown()
+	})
+
+	return &Daemon{
+		state:      s,
+		ipman:      im,
+		dns:        dnsServer,
+		forwarders: make(map[string][]*forwarder.Forwarder),
+		cancelFns:  make(map[string]context.CancelFunc),
+	}
+}
+
+// seedProject pre-populates the daemon's state and DNS with a project so
+// that OnContainerStart takes the "existing project" code path, which
+// avoids the AddLoopbackIP call that requires CAP_NET_ADMIN.
+func seedProject(d *Daemon, name, ip string) {
+	d.state.AddProject(&state.Project{Name: name, IP: ip})
+	d.dns.Register(name, ip)
+}
+
+func TestOnContainerStartAddsProject(t *testing.T) {
+	d := newTestDaemon(t)
+
+	project := "myapp"
+	ip := d.ipman.HashIP(project)
+
+	// Seed the project so we skip the AddLoopbackIP call.
+	seedProject(d, project, ip)
+
+	ctx := context.Background()
+	info := watcher.ContainerInfo{
+		Project: project,
+		Service: "web",
+		Ports:   map[int]int{8080: 32768, 443: 32769},
+	}
+
+	if err := d.OnContainerStart(ctx, info); err != nil {
+		t.Fatalf("OnContainerStart returned error: %v", err)
+	}
+
+	// Verify the project exists in state with the correct IP.
+	p := d.state.GetProject(project)
+	if p == nil {
+		t.Fatal("expected project in state, got nil")
+	}
+	if p.IP != ip {
+		t.Errorf("expected IP %s, got %s", ip, p.IP)
+	}
+
+	// Verify port mappings were recorded.
+	if len(p.Ports) != 2 {
+		t.Fatalf("expected 2 port mappings, got %d", len(p.Ports))
+	}
+
+	// Build a lookup map for easier assertion.
+	portMap := make(map[int]int)
+	for _, pm := range p.Ports {
+		portMap[pm.ContainerPort] = pm.HostPort
+	}
+	if portMap[8080] != 32768 {
+		t.Errorf("expected container port 8080 -> host 32768, got %d", portMap[8080])
+	}
+	if portMap[443] != 32769 {
+		t.Errorf("expected container port 443 -> host 32769, got %d", portMap[443])
+	}
+
+	// Verify internal forwarder tracking.
+	if len(d.forwarders[project]) != 2 {
+		t.Errorf("expected 2 forwarders, got %d", len(d.forwarders[project]))
+	}
+}
+
+func TestOnContainerDieRemovesProject(t *testing.T) {
+	d := newTestDaemon(t)
+
+	project := "myapp"
+	ip := d.ipman.HashIP(project)
+
+	// Seed and start.
+	seedProject(d, project, ip)
+
+	ctx := context.Background()
+	info := watcher.ContainerInfo{
+		Project: project,
+		Service: "web",
+		Ports:   map[int]int{8080: 32768},
+	}
+
+	if err := d.OnContainerStart(ctx, info); err != nil {
+		t.Fatalf("OnContainerStart returned error: %v", err)
+	}
+
+	// Sanity check: project exists.
+	if d.state.GetProject(project) == nil {
+		t.Fatal("project should exist after OnContainerStart")
+	}
+
+	// Die.
+	dieInfo := watcher.ContainerInfo{
+		Project: project,
+		Service: "web",
+	}
+	if err := d.OnContainerDie(ctx, dieInfo); err != nil {
+		t.Fatalf("OnContainerDie returned error: %v", err)
+	}
+
+	// Verify project is gone from state.
+	if d.state.GetProject(project) != nil {
+		t.Error("expected project to be removed from state after OnContainerDie")
+	}
+
+	// Verify forwarders and cancel functions are cleaned up.
+	if len(d.forwarders[project]) != 0 {
+		t.Errorf("expected forwarders to be cleared, got %d", len(d.forwarders[project]))
+	}
+
+	cancelCount := 0
+	for key := range d.cancelFns {
+		if len(key) > len(project) && key[:len(project)+1] == project+":" {
+			cancelCount++
+		}
+	}
+	if cancelCount != 0 {
+		t.Errorf("expected 0 cancel functions for project, got %d", cancelCount)
+	}
+}
+
+func TestOnContainerStartExistingProjectReusesIP(t *testing.T) {
+	d := newTestDaemon(t)
+
+	project := "myapp"
+	ip := d.ipman.HashIP(project)
+
+	// Seed the project.
+	seedProject(d, project, ip)
+
+	ctx := context.Background()
+
+	// First container start (service "web").
+	info1 := watcher.ContainerInfo{
+		Project: project,
+		Service: "web",
+		Ports:   map[int]int{8080: 32768},
+	}
+	if err := d.OnContainerStart(ctx, info1); err != nil {
+		t.Fatalf("first OnContainerStart returned error: %v", err)
+	}
+
+	ipAfterFirst := d.state.GetProject(project).IP
+
+	// Second container start (service "api") for the same project.
+	info2 := watcher.ContainerInfo{
+		Project: project,
+		Service: "api",
+		Ports:   map[int]int{3000: 32770},
+	}
+	if err := d.OnContainerStart(ctx, info2); err != nil {
+		t.Fatalf("second OnContainerStart returned error: %v", err)
+	}
+
+	ipAfterSecond := d.state.GetProject(project).IP
+
+	if ipAfterFirst != ipAfterSecond {
+		t.Errorf("expected same IP across container starts, got %s then %s", ipAfterFirst, ipAfterSecond)
+	}
+	if ipAfterSecond != ip {
+		t.Errorf("expected IP %s, got %s", ip, ipAfterSecond)
+	}
+}
+
+func TestTeardownAllClearsState(t *testing.T) {
+	d := newTestDaemon(t)
+	ctx := context.Background()
+
+	projects := []struct {
+		name string
+		port int
+		host int
+	}{
+		{"alpha", 8080, 32768},
+		{"bravo", 3000, 32769},
+		{"charlie", 443, 32770},
+	}
+
+	for _, p := range projects {
+		ip := d.ipman.HashIP(p.name)
+		seedProject(d, p.name, ip)
+
+		info := watcher.ContainerInfo{
+			Project: p.name,
+			Service: "web",
+			Ports:   map[int]int{p.port: p.host},
+		}
+		if err := d.OnContainerStart(ctx, info); err != nil {
+			t.Fatalf("OnContainerStart(%s) returned error: %v", p.name, err)
+		}
+	}
+
+	// Verify all projects are in state.
+	if len(d.state.ListProjects()) != 3 {
+		t.Fatalf("expected 3 projects, got %d", len(d.state.ListProjects()))
+	}
+
+	// Teardown everything.
+	d.teardownAll()
+
+	// Verify state is completely clean.
+	if len(d.state.ListProjects()) != 0 {
+		t.Errorf("expected 0 projects after teardownAll, got %d", len(d.state.ListProjects()))
+	}
+
+	if len(d.forwarders) != 0 {
+		t.Errorf("expected 0 forwarder entries after teardownAll, got %d", len(d.forwarders))
+	}
+
+	if len(d.cancelFns) != 0 {
+		t.Errorf("expected 0 cancel functions after teardownAll, got %d", len(d.cancelFns))
+	}
+}