Testing

internal/api/confmgr_rules_test.go

@@ -0,0 +1,146 @@
+package api_test
+
+import (
+	"net/http"
+	"testing"
+)
+
+// TestConfigRuleCRUD exercises the full config-rule REST surface: list, create,
+// get, update, versioning (list/get/promote/fork), check, preview, and delete,
+// plus the principal error paths.
+func TestConfigRuleCRUD(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	// A set the rule (and preview) can bind to.
+	resp := postJSON(t, srv, "/api/v1/config/sets", map[string]any{
+		"name": "S",
+		"parameters": []map[string]any{
+			{"key": "voltage", "ds": "stub", "signal": "setpoint", "type": "float64", "default": 12.0},
+		},
+	})
+	assertStatus(t, resp, http.StatusCreated)
+	var set struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &set)
+
+	// Empty list initially.
+	resp = get(t, srv, "/api/v1/config/rules")
+	assertStatus(t, resp, http.StatusOK)
+	var list []map[string]any
+	readJSON(t, resp, &list)
+	if len(list) != 0 {
+		t.Fatalf("expected no rules, got %d", len(list))
+	}
+
+	// Create.
+	resp = postJSON(t, srv, "/api/v1/config/rules", map[string]any{
+		"name":   "cap",
+		"setId":  set.ID,
+		"source": "voltage: <=24",
+	})
+	assertStatus(t, resp, http.StatusCreated)
+	var rule struct {
+		ID      string `json:"id"`
+		Version int    `json:"version"`
+	}
+	readJSON(t, resp, &rule)
+	if rule.ID == "" {
+		t.Fatal("rule missing id")
+	}
+
+	// Create with invalid CUE → 400.
+	resp = postJSON(t, srv, "/api/v1/config/rules", map[string]any{
+		"name":   "bad",
+		"setId":  set.ID,
+		"source": "voltage: <=",
+	})
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Create with malformed JSON → 400.
+	resp = postRaw(t, srv, "/api/v1/config/rules", "application/json", []byte(`{not json`))
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Get.
+	resp = get(t, srv, "/api/v1/config/rules/"+rule.ID)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Get missing → 404.
+	resp = get(t, srv, "/api/v1/config/rules/nope")
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// Update (bumps version, creates backup).
+	resp = putRaw(t, srv, "/api/v1/config/rules/"+rule.ID, "application/json",
+		[]byte(`{"name":"cap2","setId":"`+set.ID+`","source":"voltage: <=30"}`))
+	assertStatus(t, resp, http.StatusOK)
+
+	// List versions.
+	resp = get(t, srv, "/api/v1/config/rules/"+rule.ID+"/versions")
+	assertStatus(t, resp, http.StatusOK)
+	var versions []map[string]any
+	readJSON(t, resp, &versions)
+	if len(versions) < 2 {
+		t.Fatalf("expected >=2 rule versions, got %d", len(versions))
+	}
+
+	// Get v1.
+	resp = get(t, srv, "/api/v1/config/rules/"+rule.ID+"/versions/1")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Bad version path → 400.
+	resp = get(t, srv, "/api/v1/config/rules/"+rule.ID+"/versions/xyz")
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Promote v1.
+	resp = postRaw(t, srv, "/api/v1/config/rules/"+rule.ID+"/versions/1/promote", "application/json", nil)
+	assertStatus(t, resp, http.StatusOK)
+
+	// Fork v1 → new id.
+	resp = postRaw(t, srv, "/api/v1/config/rules/"+rule.ID+"/versions/1/fork", "application/json", nil)
+	assertStatus(t, resp, http.StatusCreated)
+	var fork struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &fork)
+	if fork.ID == "" || fork.ID == rule.ID {
+		t.Errorf("fork id = %q, want fresh id", fork.ID)
+	}
+
+	// Check (live validation of an unsaved source against sample values).
+	resp = postJSON(t, srv, "/api/v1/config/rules/check", map[string]any{
+		"source": "voltage: <=24",
+		"values": map[string]any{"voltage": 20.0},
+	})
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Check with malformed JSON → 400.
+	resp = postRaw(t, srv, "/api/v1/config/rules/check", "application/json", []byte(`{`))
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Preview against the bound set's live signals.
+	resp = postJSON(t, srv, "/api/v1/config/rules/preview", map[string]any{
+		"setId":  set.ID,
+		"source": "voltage: <=24",
+	})
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Preview with an unknown set → 404.
+	resp = postJSON(t, srv, "/api/v1/config/rules/preview", map[string]any{
+		"setId":  "does-not-exist",
+		"source": "voltage: <=24",
+	})
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// Delete.
+	resp = deleteReq(t, srv, "/api/v1/config/rules/"+rule.ID)
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Delete missing → 404.
+	resp = deleteReq(t, srv, "/api/v1/config/rules/"+rule.ID)
+	assertStatus(t, resp, http.StatusNotFound)
+}

internal/api/confmgr_versioning_test.go

@@ -0,0 +1,158 @@
+package api_test
+
+import (
+	"net/http"
+	"testing"
+)
+
+// TestConfigSetVersioning exercises the set update/version/promote/fork/diff and
+// snapshot endpoints that the base end-to-end test does not reach.
+func TestConfigSetVersioning(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	mk := func(name string) string {
+		resp := postJSON(t, srv, "/api/v1/config/sets", map[string]any{
+			"name": name,
+			"parameters": []map[string]any{
+				{"key": "sp", "ds": "stub", "signal": "setpoint", "type": "float64", "default": 1.0},
+			},
+		})
+		assertStatus(t, resp, http.StatusCreated)
+		var s struct {
+			ID string `json:"id"`
+		}
+		readJSON(t, resp, &s)
+		return s.ID
+	}
+
+	id := mk("Set A")
+
+	// Update → version bump + backup.
+	resp := putRaw(t, srv, "/api/v1/config/sets/"+id, "application/json",
+		[]byte(`{"name":"Set A v2","parameters":[{"key":"sp","ds":"stub","signal":"setpoint","type":"float64","default":2.0}]}`))
+	assertStatus(t, resp, http.StatusOK)
+
+	// List versions.
+	resp = get(t, srv, "/api/v1/config/sets/"+id+"/versions")
+	assertStatus(t, resp, http.StatusOK)
+	var versions []map[string]any
+	readJSON(t, resp, &versions)
+	if len(versions) < 2 {
+		t.Fatalf("expected >=2 set versions, got %d", len(versions))
+	}
+
+	// Get a specific version.
+	resp = get(t, srv, "/api/v1/config/sets/"+id+"/versions/1")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Promote v1.
+	resp = postRaw(t, srv, "/api/v1/config/sets/"+id+"/versions/1/promote", "application/json", nil)
+	assertStatus(t, resp, http.StatusOK)
+
+	// Fork v1 → new set id.
+	resp = postRaw(t, srv, "/api/v1/config/sets/"+id+"/versions/1/fork", "application/json", nil)
+	assertStatus(t, resp, http.StatusCreated)
+	var fork struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &fork)
+	if fork.ID == "" || fork.ID == id {
+		t.Errorf("fork id = %q, want fresh id", fork.ID)
+	}
+
+	// Diff the original against the fork.
+	resp = get(t, srv, "/api/v1/config/sets/diff?a="+id+"&b="+fork.ID)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Diff with a missing left id → 400.
+	resp = get(t, srv, "/api/v1/config/sets/diff?a=&b="+fork.ID)
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Snapshot the set into a new instance.
+	resp = postJSON(t, srv, "/api/v1/config/sets/"+id+"/snapshot", map[string]any{"name": "snap-1"})
+	assertStatus(t, resp, http.StatusCreated)
+	resp.Body.Close()
+}
+
+// TestConfigInstanceVersioning exercises the instance update/version/promote/
+// fork/validate and live-diff endpoints.
+func TestConfigInstanceVersioning(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	// A set to bind instances to.
+	resp := postJSON(t, srv, "/api/v1/config/sets", map[string]any{
+		"name": "Set B",
+		"parameters": []map[string]any{
+			{"key": "sp", "ds": "stub", "signal": "setpoint", "type": "float64", "default": 1.0},
+		},
+	})
+	assertStatus(t, resp, http.StatusCreated)
+	var set struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &set)
+
+	// Create an instance.
+	resp = postJSON(t, srv, "/api/v1/config/instances", map[string]any{
+		"name": "inst", "setId": set.ID, "values": map[string]any{"sp": 5.0},
+	})
+	assertStatus(t, resp, http.StatusCreated)
+	var inst struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &inst)
+
+	// Get it.
+	resp = get(t, srv, "/api/v1/config/instances/"+inst.ID)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// List instances.
+	resp = get(t, srv, "/api/v1/config/instances")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Update → version bump.
+	resp = putRaw(t, srv, "/api/v1/config/instances/"+inst.ID, "application/json",
+		[]byte(`{"name":"inst v2","setId":"`+set.ID+`","values":{"sp":7.0}}`))
+	assertStatus(t, resp, http.StatusOK)
+
+	// List versions.
+	resp = get(t, srv, "/api/v1/config/instances/"+inst.ID+"/versions")
+	assertStatus(t, resp, http.StatusOK)
+	var versions []map[string]any
+	readJSON(t, resp, &versions)
+	if len(versions) < 2 {
+		t.Fatalf("expected >=2 instance versions, got %d", len(versions))
+	}
+
+	// Get a version.
+	resp = get(t, srv, "/api/v1/config/instances/"+inst.ID+"/versions/1")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Promote + fork.
+	resp = postRaw(t, srv, "/api/v1/config/instances/"+inst.ID+"/versions/1/promote", "application/json", nil)
+	assertStatus(t, resp, http.StatusOK)
+	resp = postRaw(t, srv, "/api/v1/config/instances/"+inst.ID+"/versions/1/fork", "application/json", nil)
+	assertStatus(t, resp, http.StatusCreated)
+	resp.Body.Close()
+
+	// Validate against the (empty) rule set → 200.
+	resp = postJSON(t, srv, "/api/v1/config/instances/"+inst.ID+"/validate", nil)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Live diff against current signal values → 200.
+	resp = get(t, srv, "/api/v1/config/instances/"+inst.ID+"/livediff")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Delete the instance.
+	resp = deleteReq(t, srv, "/api/v1/config/instances/"+inst.ID)
+	assertStatus(t, resp, http.StatusNoContent)
+}

internal/api/handlers_test.go

@@ -0,0 +1,438 @@
+package api_test
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"testing"
+)
+
+// These tests exercise the many handlers reachable through the default setup()
+// harness, whose policy is unconfigured (anonymous caller → write/admin), so
+// permission gates default to "allow" and the focus is handler behaviour.
+
+// ── /me ───────────────────────────────────────────────────────────────────────
+
+func TestGetMe(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	resp := get(t, srv, "/api/v1/me")
+	assertStatus(t, resp, http.StatusOK)
+	var me map[string]any
+	readJSON(t, resp, &me)
+	for _, k := range []string{"user", "level", "groups", "canEditLogic", "canViewAudit", "canAdmin", "defaultZoom"} {
+		if _, ok := me[k]; !ok {
+			t.Errorf("/me missing key %q", k)
+		}
+	}
+	// Unconfigured policy → anonymous caller has write level.
+	if me["level"] != "write" {
+		t.Errorf("level = %v, want write", me["level"])
+	}
+}
+
+// ── /groups (signal group tree) ───────────────────────────────────────────────
+
+func TestGroupsRoundTrip(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	// Initially valid JSON.
+	resp := get(t, srv, "/api/v1/groups")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Replace with a JSON array → 204.
+	resp = putRaw(t, srv, "/api/v1/groups", "application/json", []byte(`[{"name":"A"},{"name":"B"}]`))
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Read back what we wrote.
+	resp = get(t, srv, "/api/v1/groups")
+	assertStatus(t, resp, http.StatusOK)
+	body, _ := io.ReadAll(resp.Body)
+	resp.Body.Close()
+	var tree []map[string]any
+	if err := json.Unmarshal(body, &tree); err != nil {
+		t.Fatalf("groups body not a JSON array: %v (%s)", err, body)
+	}
+	if len(tree) != 2 {
+		t.Fatalf("expected 2 groups, got %d", len(tree))
+	}
+
+	// A non-array body is rejected.
+	resp = putRaw(t, srv, "/api/v1/groups", "application/json", []byte(`{"not":"array"}`))
+	assertStatus(t, resp, http.StatusBadRequest)
+}
+
+// ── /usergroups ───────────────────────────────────────────────────────────────
+
+func TestListUserGroups(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	resp := get(t, srv, "/api/v1/usergroups")
+	assertStatus(t, resp, http.StatusOK)
+	var names []string
+	readJSON(t, resp, &names)
+	// Unconfigured policy has no named groups; the handler must still return [].
+	if names == nil {
+		t.Error("expected non-nil (possibly empty) group list")
+	}
+}
+
+// ── /folders ──────────────────────────────────────────────────────────────────
+
+func TestFolderCRUD(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	// List — initially empty.
+	resp := get(t, srv, "/api/v1/folders")
+	assertStatus(t, resp, http.StatusOK)
+	var list []any
+	readJSON(t, resp, &list)
+	if len(list) != 0 {
+		t.Fatalf("expected no folders, got %d", len(list))
+	}
+
+	// Missing name → 400.
+	resp = postJSON(t, srv, "/api/v1/folders", map[string]any{"name": ""})
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Create.
+	resp = postJSON(t, srv, "/api/v1/folders", map[string]any{"name": "Reactor"})
+	assertStatus(t, resp, http.StatusCreated)
+	var created struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &created)
+	if created.ID == "" {
+		t.Fatal("expected folder id")
+	}
+
+	// Update.
+	resp = putRaw(t, srv, "/api/v1/folders/"+created.ID, "application/json",
+		[]byte(`{"name":"Reactor Hall"}`))
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Update with empty name → 400.
+	resp = putRaw(t, srv, "/api/v1/folders/"+created.ID, "application/json", []byte(`{"name":""}`))
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Update unknown folder → 404.
+	resp = putRaw(t, srv, "/api/v1/folders/fld-nope", "application/json", []byte(`{"name":"x"}`))
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// It now appears in the list.
+	resp = get(t, srv, "/api/v1/folders")
+	assertStatus(t, resp, http.StatusOK)
+	readJSON(t, resp, &list)
+	if len(list) != 1 {
+		t.Fatalf("expected 1 folder, got %d", len(list))
+	}
+
+	// Delete.
+	resp = deleteReq(t, srv, "/api/v1/folders/"+created.ID)
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Delete unknown → 404.
+	resp = deleteReq(t, srv, "/api/v1/folders/fld-nope")
+	assertStatus(t, resp, http.StatusNotFound)
+}
+
+// ── /interfaces/{id}/acl ──────────────────────────────────────────────────────
+
+func TestPanelACL(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	resp := postRaw(t, srv, "/api/v1/interfaces", "application/xml", []byte(sampleXML))
+	assertStatus(t, resp, http.StatusCreated)
+	var created struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &created)
+
+	// GET ACL of a fresh panel.
+	resp = get(t, srv, "/api/v1/interfaces/"+created.ID+"/acl")
+	assertStatus(t, resp, http.StatusOK)
+	var acl map[string]any
+	readJSON(t, resp, &acl)
+	if _, ok := acl["perm"]; !ok {
+		t.Error("ACL response missing perm")
+	}
+
+	// PUT ACL — set a public read level.
+	resp = putRaw(t, srv, "/api/v1/interfaces/"+created.ID+"/acl", "application/json",
+		[]byte(`{"public":"read","grants":[]}`))
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// PUT ACL on a non-existent panel → 404.
+	resp = putRaw(t, srv, "/api/v1/interfaces/nope/acl", "application/json",
+		[]byte(`{"public":"read"}`))
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// PUT ACL referencing an unknown folder → 400.
+	resp = putRaw(t, srv, "/api/v1/interfaces/"+created.ID+"/acl", "application/json",
+		[]byte(`{"folder":"fld-nope"}`))
+	assertStatus(t, resp, http.StatusBadRequest)
+}
+
+// ── /interfaces/reorder ───────────────────────────────────────────────────────
+
+func TestReorderInterfaces(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	mk := func() string {
+		resp := postRaw(t, srv, "/api/v1/interfaces", "application/xml", []byte(sampleXML))
+		assertStatus(t, resp, http.StatusCreated)
+		var c struct {
+			ID string `json:"id"`
+		}
+		readJSON(t, resp, &c)
+		return c.ID
+	}
+	a, b := mk(), mk()
+
+	// Reorder at root (no folder).
+	resp := postJSON(t, srv, "/api/v1/interfaces/reorder", map[string]any{"ids": []string{b, a}})
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Reorder into a non-existent folder → 404.
+	resp = postJSON(t, srv, "/api/v1/interfaces/reorder",
+		map[string]any{"folder": "fld-nope", "ids": []string{a}})
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// Malformed body → 400.
+	resp = postRaw(t, srv, "/api/v1/interfaces/reorder", "application/json", []byte(`{not json`))
+	assertStatus(t, resp, http.StatusBadRequest)
+}
+
+// ── /interfaces/{id}/versions ─────────────────────────────────────────────────
+
+func TestInterfaceVersioning(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	resp := postRaw(t, srv, "/api/v1/interfaces", "application/xml", []byte(sampleXML))
+	assertStatus(t, resp, http.StatusCreated)
+	var created struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &created)
+	id := created.ID
+
+	// Update once to create a backup (v1) and bump current to v2.
+	upd := `<interface id="" name="Test Panel" version="2" w="800" h="600"></interface>`
+	resp = putRaw(t, srv, "/api/v1/interfaces/"+id, "application/xml", []byte(upd))
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// List versions — at least the backup.
+	resp = get(t, srv, "/api/v1/interfaces/"+id+"/versions")
+	assertStatus(t, resp, http.StatusOK)
+	var versions []map[string]any
+	readJSON(t, resp, &versions)
+	if len(versions) < 2 {
+		t.Fatalf("expected >=2 versions, got %d", len(versions))
+	}
+
+	// Get the v1 backup.
+	resp = get(t, srv, "/api/v1/interfaces/"+id+"/versions/1")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Bad version path → 400.
+	resp = get(t, srv, "/api/v1/interfaces/"+id+"/versions/abc")
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Tag v1.
+	resp = putRaw(t, srv, "/api/v1/interfaces/"+id+"/versions/1/tag?tag=golden", "application/json", nil)
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Promote v1 → becomes new current.
+	resp = postRaw(t, srv, "/api/v1/interfaces/"+id+"/versions/1/promote", "application/json", nil)
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Fork v1 → brand-new panel.
+	resp = postRaw(t, srv, "/api/v1/interfaces/"+id+"/versions/1/fork", "application/json", nil)
+	assertStatus(t, resp, http.StatusCreated)
+	var fork struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &fork)
+	if fork.ID == "" || fork.ID == id {
+		t.Errorf("fork id = %q, want fresh id", fork.ID)
+	}
+
+	// Version ops on a missing panel → 404.
+	resp = get(t, srv, "/api/v1/interfaces/missing/versions")
+	assertStatus(t, resp, http.StatusNotFound)
+}
+
+// ── /controllogic ─────────────────────────────────────────────────────────────
+
+func TestControlLogicCRUD(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	// Empty list initially.
+	resp := get(t, srv, "/api/v1/controllogic")
+	assertStatus(t, resp, http.StatusOK)
+	var list []any
+	readJSON(t, resp, &list)
+	if len(list) != 0 {
+		t.Fatalf("expected no control logic, got %d", len(list))
+	}
+
+	// Create.
+	resp = postJSON(t, srv, "/api/v1/controllogic", map[string]any{"name": "Watchdog", "enabled": true})
+	assertStatus(t, resp, http.StatusCreated)
+	var g struct {
+		ID      string `json:"id"`
+		Version int    `json:"version"`
+	}
+	readJSON(t, resp, &g)
+	if g.ID == "" {
+		t.Fatal("expected control logic id")
+	}
+
+	// Get.
+	resp = get(t, srv, "/api/v1/controllogic/"+g.ID)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Get missing → 404.
+	resp = get(t, srv, "/api/v1/controllogic/nope")
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// Update (bumps version, creates a backup).
+	resp = putRaw(t, srv, "/api/v1/controllogic/"+g.ID, "application/json",
+		[]byte(`{"name":"Watchdog v2","enabled":false}`))
+	assertStatus(t, resp, http.StatusOK)
+
+	// List versions.
+	resp = get(t, srv, "/api/v1/controllogic/"+g.ID+"/versions")
+	assertStatus(t, resp, http.StatusOK)
+	var versions []map[string]any
+	readJSON(t, resp, &versions)
+	if len(versions) < 2 {
+		t.Fatalf("expected >=2 control-logic versions, got %d", len(versions))
+	}
+
+	// Promote v1.
+	resp = postRaw(t, srv, "/api/v1/controllogic/"+g.ID+"/versions/1/promote", "application/json", nil)
+	assertStatus(t, resp, http.StatusOK)
+
+	// Fork v1 → new graph id.
+	resp = postRaw(t, srv, "/api/v1/controllogic/"+g.ID+"/versions/1/fork", "application/json", nil)
+	assertStatus(t, resp, http.StatusCreated)
+	var fork struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &fork)
+	if fork.ID == "" || fork.ID == g.ID {
+		t.Errorf("fork id = %q, want fresh id", fork.ID)
+	}
+
+	// Delete.
+	resp = deleteReq(t, srv, "/api/v1/controllogic/"+g.ID)
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Delete missing → 404.
+	resp = deleteReq(t, srv, "/api/v1/controllogic/"+g.ID)
+	assertStatus(t, resp, http.StatusNotFound)
+}
+
+// ── /audit (Nop audit log, anonymous can view on an open policy) ───────────────
+
+func TestGetAuditOpen(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	resp := get(t, srv, "/api/v1/audit")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Bad start time → 400.
+	resp = get(t, srv, "/api/v1/audit?start=not-a-time")
+	assertStatus(t, resp, http.StatusBadRequest)
+}
+
+// ── /synthetic disabled guards ────────────────────────────────────────────────
+
+// Synthetic is nil in the default harness, so every route must report 503
+// (service unavailable) rather than panicking.
+func TestSyntheticDisabledRoutes(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	cases := []struct {
+		method, path string
+		body         []byte
+	}{
+		{http.MethodGet, "/api/v1/synthetic/x", nil},
+		{http.MethodPut, "/api/v1/synthetic/x", []byte(`{}`)},
+		{http.MethodDelete, "/api/v1/synthetic/x", nil},
+		{http.MethodPost, "/api/v1/synthetic/trace", []byte(`{}`)},
+		{http.MethodGet, "/api/v1/synthetic/x/versions", nil},
+		{http.MethodGet, "/api/v1/synthetic/x/versions/1", nil},
+		{http.MethodPost, "/api/v1/synthetic/x/versions/1/promote", nil},
+		{http.MethodPost, "/api/v1/synthetic/x/versions/1/fork", nil},
+	}
+	for _, c := range cases {
+		var resp *http.Response
+		switch c.method {
+		case http.MethodGet:
+			resp = get(t, srv, c.path)
+		case http.MethodPut:
+			resp = putRaw(t, srv, c.path, "application/json", c.body)
+		case http.MethodDelete:
+			resp = deleteReq(t, srv, c.path)
+		case http.MethodPost:
+			resp = postRaw(t, srv, c.path, "application/json", c.body)
+		}
+		if resp.StatusCode != http.StatusServiceUnavailable {
+			t.Errorf("%s %s: status %d, want 503", c.method, c.path, resp.StatusCode)
+		}
+		resp.Body.Close()
+	}
+}
+
+// ── /controllogic/{id}/versions/{version} ─────────────────────────────────────
+
+func TestControlLogicGetVersion(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	resp := postJSON(t, srv, "/api/v1/controllogic", map[string]any{"name": "G"})
+	assertStatus(t, resp, http.StatusCreated)
+	var g struct {
+		ID string `json:"id"`
+	}
+	readJSON(t, resp, &g)
+
+	// Bump so a v1 backup exists.
+	resp = putRaw(t, srv, "/api/v1/controllogic/"+g.ID, "application/json", []byte(`{"name":"G2"}`))
+	assertStatus(t, resp, http.StatusOK)
+
+	resp = get(t, srv, "/api/v1/controllogic/"+g.ID+"/versions/1")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Bad version number → 400.
+	resp = get(t, srv, "/api/v1/controllogic/"+g.ID+"/versions/xyz")
+	assertStatus(t, resp, http.StatusBadRequest)
+}
+
+// ── /config/instances/diff ────────────────────────────────────────────────────
+
+func TestDiffConfigInstancesMissing(t *testing.T) {
+	srv, teardown := setup(t)
+	defer teardown()
+
+	// Missing left id → 400.
+	resp := get(t, srv, "/api/v1/config/instances/diff?a=&b=")
+	assertStatus(t, resp, http.StatusBadRequest)
+}

internal/api/helpers_white_test.go

@@ -0,0 +1,112 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/uopi/uopi/internal/access"
+	"github.com/uopi/uopi/internal/datasource"
+	"github.com/uopi/uopi/internal/datasource/synthetic"
+	"github.com/uopi/uopi/internal/panelacl"
+)
+
+// TestExtractLogicBlock covers the three branches of the <logic> extractor.
+func TestExtractLogicBlock(t *testing.T) {
+	if got := extractLogicBlock([]byte(`<i><logic><n/></logic></i>`)); got != "<logic><n/></logic>" {
+		t.Errorf("extract = %q", got)
+	}
+	if got := extractLogicBlock([]byte(`<i></i>`)); got != "" {
+		t.Errorf("no logic: want empty, got %q", got)
+	}
+	if got := extractLogicBlock([]byte(`<i><logic>unterminated`)); got != "" {
+		t.Errorf("unterminated: want empty, got %q", got)
+	}
+}
+
+// TestDataTypeName covers every DataType→token mapping plus the default.
+func TestDataTypeName(t *testing.T) {
+	cases := map[datasource.DataType]string{
+		datasource.TypeFloat64:      "float64",
+		datasource.TypeFloat64Array: "float64[]",
+		datasource.TypeString:       "string",
+		datasource.TypeInt64:        "int64",
+		datasource.TypeBool:         "bool",
+		datasource.TypeEnum:         "enum",
+		datasource.DataType(255):    "unknown",
+	}
+	for typ, want := range cases {
+		if got := dataTypeName(typ); got != want {
+			t.Errorf("dataTypeName(%v) = %q, want %q", typ, got, want)
+		}
+	}
+}
+
+// TestSynVisible covers each visibility branch of synVisible.
+func TestSynVisible(t *testing.T) {
+	cases := []struct {
+		name   string
+		def    synthetic.SignalDef
+		user   string
+		panel  string
+		groups []string
+		want   bool
+	}{
+		{"user own", synthetic.SignalDef{Visibility: "user", Owner: "alice"}, "alice", "", nil, true},
+		{"user other", synthetic.SignalDef{Visibility: "user", Owner: "alice"}, "bob", "", nil, false},
+		{"panel match", synthetic.SignalDef{Visibility: "panel", Panel: "p1"}, "bob", "p1", nil, true},
+		{"panel mismatch", synthetic.SignalDef{Visibility: "panel", Panel: "p1"}, "bob", "p2", nil, false},
+		{"global", synthetic.SignalDef{Visibility: "global"}, "", "", nil, true},
+		{"legacy empty", synthetic.SignalDef{}, "", "", nil, true},
+		{"group member", synthetic.SignalDef{Visibility: "group", Owner: "alice", Groups: []string{"ops"}}, "bob", "", []string{"ops"}, true},
+		{"group outsider", synthetic.SignalDef{Visibility: "group", Owner: "alice", Groups: []string{"ops"}}, "bob", "", []string{"hr"}, false},
+	}
+	for _, tc := range cases {
+		if got := synVisible(tc.def, tc.user, tc.panel, tc.groups); got != tc.want {
+			t.Errorf("%s: synVisible = %v, want %v", tc.name, got, tc.want)
+		}
+	}
+}
+
+// TestPanelScope covers the nil/public→global, group, and private branches.
+func TestPanelScope(t *testing.T) {
+	if sc, _ := panelScope(nil); sc != access.ScopeGlobal {
+		t.Errorf("nil acl: scope = %q, want global", sc)
+	}
+	if sc, _ := panelScope(&panelacl.PanelACL{Public: "read"}); sc != access.ScopeGlobal {
+		t.Errorf("public acl: scope = %q, want global", sc)
+	}
+	sc, groups := panelScope(&panelacl.PanelACL{
+		Grants: []panelacl.Grant{{Kind: "group", Name: "ops"}, {Kind: "user", Name: "x"}},
+	})
+	if sc != access.ScopeGroup || len(groups) != 1 || groups[0] != "ops" {
+		t.Errorf("group acl: scope=%q groups=%v", sc, groups)
+	}
+	if sc, _ := panelScope(&panelacl.PanelACL{Owner: "alice"}); sc != access.ScopePrivate {
+		t.Errorf("private acl: scope = %q, want private", sc)
+	}
+}
+
+// TestClientIP covers the XFF, X-Real-IP, host:port, and bare-RemoteAddr cases.
+func TestClientIP(t *testing.T) {
+	mk := func(set func(*http.Request)) *http.Request {
+		r := httptest.NewRequest(http.MethodGet, "/", nil)
+		set(r)
+		return r
+	}
+	if got := clientIP(mk(func(r *http.Request) { r.Header.Set("X-Forwarded-For", "1.2.3.4, 5.6.7.8") })); got != "1.2.3.4" {
+		t.Errorf("XFF list: got %q", got)
+	}
+	if got := clientIP(mk(func(r *http.Request) { r.Header.Set("X-Forwarded-For", "9.9.9.9") })); got != "9.9.9.9" {
+		t.Errorf("XFF single: got %q", got)
+	}
+	if got := clientIP(mk(func(r *http.Request) { r.Header.Set("X-Real-IP", "8.8.8.8") })); got != "8.8.8.8" {
+		t.Errorf("X-Real-IP: got %q", got)
+	}
+	if got := clientIP(mk(func(r *http.Request) { r.RemoteAddr = "10.0.0.1:5555" })); got != "10.0.0.1" {
+		t.Errorf("host:port: got %q", got)
+	}
+	if got := clientIP(mk(func(r *http.Request) { r.RemoteAddr = "bare-addr" })); got != "bare-addr" {
+		t.Errorf("bare addr: got %q", got)
+	}
+}

internal/api/synthetic_test.go

@@ -0,0 +1,175 @@
+package api_test
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/uopi/uopi/internal/access"
+	"github.com/uopi/uopi/internal/api"
+	"github.com/uopi/uopi/internal/audit"
+	"github.com/uopi/uopi/internal/broker"
+	"github.com/uopi/uopi/internal/confmgr"
+	"github.com/uopi/uopi/internal/controllogic"
+	"github.com/uopi/uopi/internal/datasource/stub"
+	"github.com/uopi/uopi/internal/datasource/synthetic"
+	"github.com/uopi/uopi/internal/panelacl"
+	"github.com/uopi/uopi/internal/storage"
+)
+
+// setupSynthetic builds an API server whose synthetic data source is enabled, so
+// the synthetic CRUD/versioning/trace handlers run their real bodies.
+func setupSynthetic(t *testing.T) (*httptest.Server, func()) {
+	t.Helper()
+	ctx, cancel := context.WithCancel(context.Background())
+	log := slog.New(slog.NewTextHandler(io.Discard, nil))
+	brk := broker.New(ctx, log)
+	ds := stub.New()
+	if err := ds.Connect(ctx); err != nil {
+		t.Fatal("stub connect:", err)
+	}
+	brk.Register(ds)
+
+	dir := t.TempDir()
+	store, _ := storage.New(dir)
+	acl, _ := panelacl.New(dir)
+	clStore, _ := controllogic.NewStore(dir)
+	cfgStore, _ := confmgr.New(dir)
+	clEngine := controllogic.NewEngine(ctx, brk, clStore, cfgStore, audit.Nop(), log)
+
+	synthDS := synthetic.New(dir, brk, log)
+	if err := synthDS.Connect(ctx); err != nil {
+		t.Fatal("synthetic connect:", err)
+	}
+	brk.Register(synthDS)
+
+	mux := http.NewServeMux()
+	api.New(brk, synthDS, store, cfgStore, access.New("", nil), acl, clStore, clEngine, audit.Nop(), "", "", 0, log).Register(mux, "/api/v1")
+
+	srv := httptest.NewServer(mux)
+	return srv, func() { srv.Close(); cancel() }
+}
+
+// putJSON marshals body and issues a PUT, mirroring postJSON.
+func putJSON(t *testing.T, srv *httptest.Server, path string, body any) *http.Response {
+	t.Helper()
+	b, err := json.Marshal(body)
+	if err != nil {
+		t.Fatal("json.Marshal:", err)
+	}
+	return putRaw(t, srv, path, "application/json", b)
+}
+
+// syntheticBody returns a minimal valid graph signal sourced from the stub's
+// "sine" signal through a gain op.
+func syntheticBody(name string) map[string]any {
+	return map[string]any{
+		"name":       name,
+		"visibility": "global",
+		"graph": map[string]any{
+			"output": "out",
+			"nodes": []map[string]any{
+				{"id": "a", "kind": "source", "ds": "stub", "signal": "sine"},
+				{"id": "g", "kind": "op", "op": "gain", "inputs": []string{"a"},
+					"params": map[string]any{"k": 2.0}},
+				{"id": "out", "kind": "output", "inputs": []string{"g"}},
+			},
+		},
+	}
+}
+
+func TestSyntheticCRUDEnabled(t *testing.T) {
+	srv, teardown := setupSynthetic(t)
+	defer teardown()
+
+	// List — initially empty.
+	resp := get(t, srv, "/api/v1/synthetic")
+	assertStatus(t, resp, http.StatusOK)
+	var list []any
+	readJSON(t, resp, &list)
+	if len(list) != 0 {
+		t.Fatalf("expected no synthetic signals, got %d", len(list))
+	}
+
+	// Create.
+	resp = postJSON(t, srv, "/api/v1/synthetic", syntheticBody("doubled"))
+	assertStatus(t, resp, http.StatusCreated)
+	resp.Body.Close()
+
+	// Duplicate create → 400 (AddSignal rejects an existing name).
+	resp = postJSON(t, srv, "/api/v1/synthetic", syntheticBody("doubled"))
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Invalid JSON → 400.
+	resp = postRaw(t, srv, "/api/v1/synthetic", "application/json", []byte(`{bad`))
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Get.
+	resp = get(t, srv, "/api/v1/synthetic/doubled")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Get missing → 404.
+	resp = get(t, srv, "/api/v1/synthetic/nope")
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// Update (changes gain factor).
+	upd := syntheticBody("doubled")
+	upd["graph"].(map[string]any)["nodes"].([]map[string]any)[1]["params"] = map[string]any{"k": 3.0}
+	resp = putJSON(t, srv, "/api/v1/synthetic/doubled", upd)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Update missing → 404.
+	resp = putJSON(t, srv, "/api/v1/synthetic/nope", syntheticBody("nope"))
+	assertStatus(t, resp, http.StatusNotFound)
+
+	// Versions list (the update created a backup).
+	resp = get(t, srv, "/api/v1/synthetic/doubled/versions")
+	assertStatus(t, resp, http.StatusOK)
+	var versions []map[string]any
+	readJSON(t, resp, &versions)
+	if len(versions) < 2 {
+		t.Fatalf("expected >=2 synthetic versions, got %d", len(versions))
+	}
+
+	// Get v1.
+	resp = get(t, srv, "/api/v1/synthetic/doubled/versions/1")
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Bad version → 400.
+	resp = get(t, srv, "/api/v1/synthetic/doubled/versions/xyz")
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Promote v1.
+	resp = postRaw(t, srv, "/api/v1/synthetic/doubled/versions/1/promote", "application/json", nil)
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Fork v1 → new signal.
+	resp = postRaw(t, srv, "/api/v1/synthetic/doubled/versions/1/fork", "application/json", nil)
+	assertStatus(t, resp, http.StatusCreated)
+	resp.Body.Close()
+
+	// Trace an unsaved graph.
+	resp = postJSON(t, srv, "/api/v1/synthetic/trace", syntheticBody("scratch"))
+	assertStatus(t, resp, http.StatusOK)
+	resp.Body.Close()
+
+	// Trace with invalid JSON → 400.
+	resp = postRaw(t, srv, "/api/v1/synthetic/trace", "application/json", []byte(`{bad`))
+	assertStatus(t, resp, http.StatusBadRequest)
+
+	// Delete.
+	resp = deleteReq(t, srv, "/api/v1/synthetic/doubled")
+	assertStatus(t, resp, http.StatusNoContent)
+
+	// Delete missing → 404.
+	resp = deleteReq(t, srv, "/api/v1/synthetic/doubled")
+	assertStatus(t, resp, http.StatusNotFound)
+}