160 lines
7.1 KiB
Go
160 lines
7.1 KiB
Go
package platform
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func aiPlanFixture(edges [][2]string, disabled map[string]bool, unconfigured string) map[string]canvasSnapshot {
|
|
ids := map[string]bool{"a": true}
|
|
for _, e := range edges {
|
|
ids[e[0]] = true
|
|
ids[e[1]] = true
|
|
}
|
|
nodes := []any{}
|
|
for id := range ids {
|
|
data := map[string]any{"kind": "text", "title": id, "text": "frozen"}
|
|
if id != unconfigured {
|
|
data["ai"] = map[string]any{"enabled": true, "modelId": "fixture-model", "prompt": "transform", "parameters": map[string]any{}}
|
|
}
|
|
nodes = append(nodes, map[string]any{"id": id, "type": "material", "position": map[string]any{"x": 0, "y": 0}, "data": data})
|
|
}
|
|
values := []any{}
|
|
for _, edge := range edges {
|
|
id := edge[0] + "-" + edge[1]
|
|
values = append(values, map[string]any{"id": id, "source": edge[0], "target": edge[1], "data": map[string]any{"execution": map[string]any{"enabled": !disabled[id]}}})
|
|
}
|
|
raw, _ := json.Marshal(map[string]any{"schema_version": 2, "nodes": nodes, "edges": values, "viewport": map[string]any{"x": 0, "y": 0, "zoom": 1}})
|
|
return map[string]canvasSnapshot{"board": {BoardID: "board", Version: 4, Document: raw}}
|
|
}
|
|
func TestAIPlanDiamondAndPropagationBoundaries(t *testing.T) {
|
|
graph := aiPlanFixture([][2]string{{"a", "b"}, {"a", "c"}, {"b", "d"}, {"c", "d"}}, nil, "")
|
|
plan, err := buildCanvasAIPlan(graph, "board", "a", true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(plan.Steps) != 4 || len(plan.Edges) != 4 {
|
|
t.Fatal("diamond duplicated step")
|
|
}
|
|
if plan.Steps[3].NodeID != "d" || len(plan.Steps[3].Dependencies) != 2 {
|
|
t.Fatal("merge did not wait for both predecessors")
|
|
}
|
|
single, err := buildCanvasAIPlan(graph, "board", "a", false)
|
|
if err != nil || len(single.Steps) != 1 || len(single.Edges) != 0 {
|
|
t.Fatal("propagate false traversed edges")
|
|
}
|
|
graph = aiPlanFixture([][2]string{{"a", "b"}, {"b", "c"}}, nil, "b")
|
|
stopped, err := buildCanvasAIPlan(graph, "board", "a", true)
|
|
if err != nil || len(stopped.Steps) != 2 || stopped.Steps[1].Status != "skipped" {
|
|
t.Fatal("unconfigured node did not stop traversal")
|
|
}
|
|
graph = aiPlanFixture([][2]string{{"a", "b"}, {"b", "c"}}, map[string]bool{"a-b": true}, "")
|
|
decoration, err := buildCanvasAIPlan(graph, "board", "a", true)
|
|
if err != nil || len(decoration.Steps) != 1 {
|
|
t.Fatal("decorative edge executed")
|
|
}
|
|
graph = aiPlanFixture([][2]string{{"a", "b"}, {"b", "a"}}, nil, "")
|
|
if _, err := buildCanvasAIPlan(graph, "board", "a", true); err == nil || err.Error() != "execution_cycle" {
|
|
t.Fatal("cycle accepted")
|
|
}
|
|
}
|
|
func TestAITargetFingerprintIgnoresVisualEdits(t *testing.T) {
|
|
data := map[string]any{"kind": "text", "text": "original", "title": "Title", "rotation": 0, "ai": map[string]any{"modelId": "fixture", "prompt": "prompt", "enabled": true}}
|
|
original := canvasTargetFingerprint("board", "node", data)
|
|
data["rotation"] = 90
|
|
data["textStyle"] = map[string]any{"color": "#FFFFFF"}
|
|
data["title"] = "Renamed"
|
|
if canvasTargetFingerprint("board", "node", data) != original {
|
|
t.Fatal("visual edit caused conflict")
|
|
}
|
|
data["text"] = "edited"
|
|
if canvasTargetFingerprint("board", "node", data) == original {
|
|
t.Fatal("content edit ignored")
|
|
}
|
|
data["text"] = "original"
|
|
if canvasTargetFingerprint("other", "node", data) == original {
|
|
t.Fatal("ownership edit ignored")
|
|
}
|
|
// JSON object key order must not affect the hash.
|
|
var reordered map[string]any
|
|
_ = json.Unmarshal([]byte(`{"ai":{"enabled":true,"prompt":"prompt","modelId":"fixture"},"text":"original","kind":"text"}`), &reordered)
|
|
if canvasTargetFingerprint("board", "node", reordered) != original {
|
|
t.Fatal("noncanonical fingerprint")
|
|
}
|
|
if validCanvasAI(map[string]any{"prompt": strings.Repeat("x", 16001)}, "text") {
|
|
t.Fatal("oversize prompt accepted")
|
|
}
|
|
if validCanvasAI(map[string]any{"enabled": true}, "icon") {
|
|
t.Fatal("icon AI accepted")
|
|
}
|
|
}
|
|
|
|
func TestAIPlanFreezesAdditionalStaticInputs(t *testing.T) {
|
|
graph := aiPlanFixture([][2]string{{"x", "a"}, {"a", "b"}}, nil, "")
|
|
plan, err := buildCanvasAIPlan(graph, "board", "a", true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(plan.Steps) != 2 || len(plan.Steps[0].StaticInputs) != 1 || plan.Steps[0].StaticInputs[0].NodeID != "x" {
|
|
t.Fatal("static predecessor not frozen")
|
|
}
|
|
if plan.Steps[0].StaticInputs[0].Content["text"] != "frozen" {
|
|
t.Fatal("static source content missing")
|
|
}
|
|
single, err := buildCanvasAIPlan(graph, "board", "a", false)
|
|
if err != nil || len(single.Steps) != 1 || len(single.Steps[0].StaticInputs) != 1 {
|
|
t.Fatal("propagate false lost static input or executed predecessor")
|
|
}
|
|
task, err := assembleCanvasTask(plan, plan.Steps[0], nil)
|
|
if err != nil || !strings.Contains(task.Prompt, "static_inputs") || !strings.Contains(task.Prompt, "board/x-a") {
|
|
t.Fatal("static input not supplied to model")
|
|
}
|
|
}
|
|
func TestAIPlanLeavesChildThroughNestedPortChain(t *testing.T) {
|
|
raw := memberFixture(t)
|
|
child := "11111111-1111-4111-8111-111111111111"
|
|
inner := "33333333-3333-4333-8333-333333333333"
|
|
var parent, childDoc map[string]any
|
|
_ = json.Unmarshal(raw["parent"], &parent)
|
|
_ = json.Unmarshal(raw[child], &childDoc)
|
|
for _, v := range parent["nodes"].([]any) {
|
|
n := v.(map[string]any)
|
|
d := n["data"].(map[string]any)
|
|
if n["id"] == "outside" {
|
|
d["ai"] = map[string]any{"enabled": true, "modelId": "fixture", "prompt": "transform", "parameters": map[string]any{}}
|
|
}
|
|
if n["id"] == "f" {
|
|
for _, p := range d["ports"].([]any) {
|
|
port := p.(map[string]any)
|
|
port["nodeId"] = "nested"
|
|
port["handle"] = "port:deep-out"
|
|
}
|
|
}
|
|
}
|
|
childDoc["nodes"] = append(childDoc["nodes"].([]any), map[string]any{"id": "nested", "type": "frame", "position": map[string]any{"x": 0, "y": 0}, "width": 400, "height": 300, "data": map[string]any{"kind": "frame", "title": "Nested", "text": "", "subgraph": map[string]any{"boardId": inner}, "ports": []any{map[string]any{"id": "deep-out", "direction": "output", "nodeId": "deep", "handle": "right"}}}})
|
|
innerDoc := map[string]any{"schema_version": 2, "nodes": []any{map[string]any{"id": "deep", "type": "material", "position": map[string]any{"x": 0, "y": 0}, "data": map[string]any{"kind": "text", "title": "Deep", "text": "frozen", "ai": map[string]any{"enabled": true, "modelId": "fixture", "prompt": "transform", "parameters": map[string]any{}}}}}, "edges": []any{}, "viewport": map[string]any{"x": 0, "y": 0, "zoom": 1}}
|
|
raw["parent"], _ = json.Marshal(parent)
|
|
raw[child], _ = json.Marshal(childDoc)
|
|
raw[inner], _ = json.Marshal(innerDoc)
|
|
snapshots := map[string]canvasSnapshot{}
|
|
for board, doc := range raw {
|
|
snapshots[board] = canvasSnapshot{BoardID: board, Version: 7, Document: doc}
|
|
}
|
|
plan, err := buildCanvasAIPlan(snapshots, inner, "deep", true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(plan.Steps) != 2 || plan.Steps[0].NodeID != "deep" || plan.Steps[1].NodeID != "outside" || len(plan.Edges) != 2 {
|
|
t.Fatal("nested boundary chain did not resolve to one node execution")
|
|
}
|
|
for _, edge := range plan.Edges {
|
|
if edge.Source != canvasNodeKey(inner, "deep") {
|
|
t.Fatal("frame executed as a separate step")
|
|
}
|
|
}
|
|
if plan.Versions[child] != 7 || plan.Versions["parent"] != 7 {
|
|
t.Fatal("port-chain owner versions not frozen")
|
|
}
|
|
}
|