Files
Bedrock/internal/platform/canvas_ai_plan_test.go
codex-bot d6ee8942f1
Foundry Go checks / check (push) Successful in 2m40s
Foundry Go checks / check (pull_request) Successful in 2m36s
Implement Canvas V2 subgraphs, assets and asynchronous AI execution
2026-11-06 18:36:00 +08:00

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")
}
}