tiny-forge/internal/reconciler/reconciler_test.go

package reconciler

import (
	"context"
	"testing"

	"github.com/alexei/tinyforge/internal/docker"
	"github.com/alexei/tinyforge/internal/store"
)

// fakeDocker is a tiny stand-in for docker.Client. The reconciler depends on
// the DockerLister interface so we don't need a real daemon for unit tests.
type fakeDocker struct {
	items []docker.ReconcileItem
}

func (f *fakeDocker) ListAllForReconciler(ctx context.Context) ([]docker.ReconcileItem, error) {
	return f.items, nil
}

func newTestStore(t *testing.T) *store.Store {
	t.Helper()
	s, err := store.New(":memory:")
	if err != nil {
		t.Fatalf("create store: %v", err)
	}
	t.Cleanup(func() { s.Close() })
	return s
}

func TestReconcileWorkloadLabelledStackContainer(t *testing.T) {
	st := newTestStore(t)

	// Set up a stack workload (no project/site interaction).
	stack, err := st.CreateStack(store.Stack{
		Name: "wf-stack", ComposeProjectName: "tinyforge-wf-stack",
	})
	if err != nil {
		t.Fatalf("CreateStack: %v", err)
	}
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// One container with the canonical workload labels stamped.
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID:    "docker-abc",
		Name:  "wf-stack-web-1",
		Image: "nginx:1.27",
		State: "running",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   w.ID,
			docker.LabelWorkloadKind: "stack",
			docker.LabelRole:         "web",
		},
		Ports: []uint16{8080},
	}}}

	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	rows, _ := st.ListContainersByWorkload(w.ID)
	if len(rows) != 1 {
		t.Fatalf("expected 1 container row, got %d", len(rows))
	}
	got := rows[0]
	if got.ContainerID != "docker-abc" {
		t.Fatalf("container_id not bound: got %q", got.ContainerID)
	}
	if got.Role != "web" || got.WorkloadKind != "stack" {
		t.Fatalf("dispatch wrong: %+v", got)
	}
	if got.State != "running" || got.Port != 8080 {
		t.Fatalf("state/port wrong: %+v", got)
	}
}

func TestReconcileComposeOnlyStackContainer(t *testing.T) {
	st := newTestStore(t)

	stack, _ := st.CreateStack(store.Stack{
		Name: "compose-stack", ComposeProjectName: "tinyforge-compose-stack",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// Pre-existing compose container — only carries compose's own labels,
	// no tinyforge.* labels at all.
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID:    "docker-xyz",
		Name:  "tinyforge-compose-stack-worker-1",
		Image: "redis:7",
		State: "running",
		Labels: map[string]string{
			"com.docker.compose.project": "tinyforge-compose-stack",
			"com.docker.compose.service": "worker",
		},
	}}}

	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	rows, _ := st.ListContainersByWorkload(w.ID)
	if len(rows) != 1 {
		t.Fatalf("expected 1 row, got %d", len(rows))
	}
	if rows[0].Role != "worker" {
		t.Fatalf("role from compose label wrong: %q", rows[0].Role)
	}
	if rows[0].ContainerID != "docker-xyz" {
		t.Fatalf("container_id not bound: %q", rows[0].ContainerID)
	}
}

func TestReconcileMarksMissingRows(t *testing.T) {
	st := newTestStore(t)

	stack, _ := st.CreateStack(store.Stack{
		Name: "missing-stack", ComposeProjectName: "tinyforge-missing-stack",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// Pre-existing row with a real container_id that no longer exists.
	if err := st.UpsertContainer(store.Container{
		ID: w.ID + ":web", WorkloadID: w.ID, WorkloadKind: "stack",
		Role: "web", ContainerID: "docker-gone", State: "running",
	}); err != nil {
		t.Fatalf("seed: %v", err)
	}

	// Reconciler sees nothing.
	r := New(st, &fakeDocker{}, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID(w.ID + ":web")
	if got.State != "missing" {
		t.Fatalf("expected state=missing, got %q", got.State)
	}
}

func TestReconcileSkipsRowsAwaitingDocker(t *testing.T) {
	st := newTestStore(t)

	stack, _ := st.CreateStack(store.Stack{
		Name: "pending", ComposeProjectName: "tinyforge-pending",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	// A row with empty container_id (deployer placeholder, awaiting docker
	// create). Reconciler must not mark this as missing.
	if err := st.UpsertContainer(store.Container{
		ID: w.ID + ":web", WorkloadID: w.ID, WorkloadKind: "stack",
		Role: "web", ContainerID: "", State: "starting",
	}); err != nil {
		t.Fatalf("seed: %v", err)
	}

	r := New(st, &fakeDocker{}, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID(w.ID + ":web")
	if got.State != "starting" {
		t.Fatalf("placeholder row should keep state, got %q", got.State)
	}
}

func TestReconcileIgnoresUnmanagedContainers(t *testing.T) {
	// A container without any tinyforge or compose labels would not even be
	// returned by ListAllForReconciler in production; but the dispatch must
	// be a no-op even if a stray item slips through.
	st := newTestStore(t)
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID: "docker-foreign", Labels: map[string]string{"app": "other"},
	}}}
	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}
	rows, _ := st.ListContainers(store.ContainerFilter{})
	if len(rows) != 0 {
		t.Fatalf("foreign container should not produce rows, got %d", len(rows))
	}
}

// TestReconcileDoesNotClobberDeployerFields guards against the regression where
// the reconciler's upsert wiped subdomain / proxy_route_id / npm_proxy_id /
// image_tag / stage_id on every tick because those columns were included in
// the ON CONFLICT DO UPDATE SET clause but never populated by the reconciler.
func TestReconcileDoesNotClobberDeployerFields(t *testing.T) {
	st := newTestStore(t)

	// Project workload — exercises the path most affected by the regression
	// (proxies, blue-green slots, image-tag-based stale detection).
	project, err := st.CreateProject(store.Project{Name: "p", Image: "nginx"})
	if err != nil {
		t.Fatalf("CreateProject: %v", err)
	}
	w, _ := st.GetWorkloadByRef(store.WorkloadKindProject, project.ID)

	// Deployer wrote the row with proxy / subdomain / image_tag / stage_id.
	deployerRow := store.Container{
		ID: "deploy-uuid-1", WorkloadID: w.ID, WorkloadKind: "project",
		Role: "prod", StageID: "stage-prod-id", ContainerID: "docker-aaa",
		ImageRef: "nginx:1.27", ImageTag: "1.27", State: "running", Port: 8080,
		Subdomain: "prod-p", ProxyRouteID: "route-42", NpmProxyID: 7,
	}
	if err := st.UpsertContainer(deployerRow); err != nil {
		t.Fatalf("seed deployer row: %v", err)
	}

	// Reconciler sees the same docker container — no proxy fields in labels.
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID: "docker-aaa", Image: "nginx:1.27", State: "running",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   w.ID,
			docker.LabelWorkloadKind: "project",
			docker.LabelRole:         "prod",
		},
		Ports: []uint16{8080},
	}}}
	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID("deploy-uuid-1")
	if got.Subdomain != "prod-p" {
		t.Fatalf("subdomain wiped: %q", got.Subdomain)
	}
	if got.ProxyRouteID != "route-42" {
		t.Fatalf("proxy_route_id wiped: %q", got.ProxyRouteID)
	}
	if got.NpmProxyID != 7 {
		t.Fatalf("npm_proxy_id wiped: %d", got.NpmProxyID)
	}
	if got.ImageTag != "1.27" {
		t.Fatalf("image_tag wiped: %q", got.ImageTag)
	}
	if got.StageID != "stage-prod-id" {
		t.Fatalf("stage_id wiped: %q", got.StageID)
	}
}

// TestReconcileRejectsForgedWorkloadLabel guards C2 — a Docker container
// claiming a non-existent workload_id must be ignored, not adopted into the
// containers index.
func TestReconcileRejectsForgedWorkloadLabel(t *testing.T) {
	st := newTestStore(t)
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID: "docker-evil",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   "wl-does-not-exist",
			docker.LabelWorkloadKind: "project",
			docker.LabelRole:         "prod",
		},
	}}}
	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}
	rows, _ := st.ListContainers(store.ContainerFilter{})
	if len(rows) != 0 {
		t.Fatalf("forged label should produce no row, got %d", len(rows))
	}
}

// TestReconcileSkipsProjectInsertWithoutDeployerRow guards H3 — the reconciler
// must not invent a project container row, since the deployer is the
// authoritative writer and inventing rows races with MaxInstances > 1 deploys.
func TestReconcileSkipsProjectInsertWithoutDeployerRow(t *testing.T) {
	st := newTestStore(t)
	project, err := st.CreateProject(store.Project{Name: "p2", Image: "nginx"})
	if err != nil {
		t.Fatalf("CreateProject: %v", err)
	}
	w, _ := st.GetWorkloadByRef(store.WorkloadKindProject, project.ID)

	// Reconciler sees a real container with project labels but no deployer
	// row exists yet (race during deploy).
	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID: "docker-race", Image: "nginx", State: "running",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   w.ID,
			docker.LabelWorkloadKind: "project",
			docker.LabelRole:         "prod",
		},
	}}}
	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}
	rows, _ := st.ListContainersByWorkload(w.ID)
	if len(rows) != 0 {
		t.Fatalf("project insert without deployer row should be skipped, got %d rows", len(rows))
	}
}

func TestReconcileNormalizesState(t *testing.T) {
	st := newTestStore(t)
	stack, _ := st.CreateStack(store.Stack{
		Name: "norm", ComposeProjectName: "tinyforge-norm",
	})
	w, _ := st.GetWorkloadByRef(store.WorkloadKindStack, stack.ID)

	fake := &fakeDocker{items: []docker.ReconcileItem{{
		ID:    "docker-1",
		Image: "nginx",
		State: "exited",
		Labels: map[string]string{
			docker.LabelManaged:      "true",
			docker.LabelWorkloadID:   w.ID,
			docker.LabelWorkloadKind: "stack",
			docker.LabelRole:         "web",
		},
	}}}

	r := New(st, fake, 0)
	if err := r.ReconcileOnce(context.Background()); err != nil {
		t.Fatalf("ReconcileOnce: %v", err)
	}

	got, _ := st.GetContainerByID(w.ID + ":web")
	if got.State != "stopped" {
		t.Fatalf("docker 'exited' should normalize to 'stopped', got %q", got.State)
	}
}