package platform import ( "bytes" "context" "crypto/rand" "crypto/sha256" "database/sql" "encoding/base64" "encoding/hex" "encoding/json" "image" "image/png" "net" "net/http" "net/http/httptest" "os" "path/filepath" "strconv" "strings" "sync/atomic" "testing" "gitea.entroia.com/Zayden-Jung/foundry-core/internal/codex" ) func TestCanonicalAIAdmissionAndLifecycle(t *testing.T) { dsn := os.Getenv("PLATFORM_TEST_DATABASE_URL") if dsn == "" { t.Skip("requires an isolated integration database") } db, err := sql.Open("pgx", dsn) if err != nil { t.Fatal(err) } defer db.Close() ctx := context.Background() var entropy [32]byte _, _ = rand.Read(entropy[:]) project := "canonical-ai-" + hex.EncodeToString(entropy[:8]) token := base64.RawURLEncoding.EncodeToString(entropy[:]) digest := sha256.Sum256([]byte(token)) var account, workspace, root string if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, project).Scan(&account); err != nil { t.Fatal(err) } defer func() { for _, table := range []string{"canvas_ai_runs", "canvas_model_operations", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_projects", "canvas_asset_bindings", "canvas_assets", "canvas_subgraphs", "workspaces", "project_accounts"} { _, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", project) } }() if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions(token_hash,project,account_id,expires_at) VALUES($1,$2,$3,now()+interval '1 hour')`, base64.RawURLEncoding.EncodeToString(digest[:]), project, account); err != nil { t.Fatal(err) } if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Canonical AI',$2) RETURNING id::text`, project, account).Scan(&workspace); err != nil { t.Fatal(err) } if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members(project,workspace_id,account_id,role) VALUES($1,$2,$3,'admin')`, project, workspace, account); err != nil { t.Fatal(err) } if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Canonical AI',$3,$4) RETURNING id::text`, project, workspace, account, json.RawMessage(canvasFixture)).Scan(&root); err != nil { t.Fatal(err) } temp, err := os.MkdirTemp("", "fc-canonical-ai-") if err != nil { t.Fatal(err) } defer os.RemoveAll(temp) socket := filepath.Join(temp, "worker.sock") listener, err := net.Listen("unix", socket) if err != nil { t.Fatal(err) } var pngBytes bytes.Buffer if err = png.Encode(&pngBytes, image.NewRGBA(image.Rect(0, 0, 3, 2))); err != nil { t.Fatal(err) } hooks := make(chan func(), 1) var executions atomic.Int32 worker := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/canvas/models" { reply(w, 200, response{"models": []any{codex.CanvasModel{ID: "text", Available: true, InputModalities: []string{"text", "image"}, OutputModalities: []string{"text"}, MaxInputBytes: 1 << 20, MaxExecutionMS: 90000}, codex.CanvasModel{ID: "image", Available: true, InputModalities: []string{"text", "image"}, OutputModalities: []string{"image"}, MaxInputBytes: 1 << 20, MaxExecutionMS: 180000}}}) return } if r.URL.Path != "/canvas/exec" { reject(w, 404, "not_found") return } var task codex.CanvasTask if json.NewDecoder(r.Body).Decode(&task) != nil { reject(w, 400, "invalid_request") return } executions.Add(1) select { case hook := <-hooks: hook() default: } if task.OutputModality == "image" { reply(w, 200, response{"output": codex.CanvasOutput{Kind: "image", Image: &codex.CanvasImage{MIME: "image/png", Data: pngBytes.Bytes()}}}) } else { reply(w, 200, response{"result": "generated result"}) } })} go worker.Serve(listener) defer worker.Close() s := &service{db: db, origin: "https://api.example.com", canvasAI: codex.NewCanvasClient(socket)} callbacks := map[string]string{project: "https://app.example.com/auth/callback"} mux := http.NewServeMux() prefix := "/projects/{project}/workspaces/{workspace}/materials/{material}/canvas" mux.HandleFunc(prefix+"/model", s.protected(callbacks, s.getCanvasModel)) mux.HandleFunc(prefix+"/model/migrate", s.protected(callbacks, s.migrateCanonicalCanvas)) mux.HandleFunc(prefix+"/ai/runs", s.protected(callbacks, s.createCanvasAIRun)) mux.HandleFunc(prefix+"/ai/runs/{run}", s.protected(callbacks, s.getCanvasAIRun)) mux.HandleFunc(prefix+"/ai/runs/{run}/apply", s.protected(callbacks, s.applyCanvasAIOutput)) mux.HandleFunc(prefix+"/ai/runs/{run}/cancel", s.protected(callbacks, s.cancelCanvasAIRun)) mux.HandleFunc(prefix+"/ai/operations/{request}", s.protected(callbacks, s.getCanvasAIAdmission)) mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/{asset}", s.protected(callbacks, s.getAsset)) base := func(board string) string { return "/projects/" + project + "/workspaces/" + workspace + "/materials/" + board + "/canvas" } call := func(method, path string, input any, status int, version int64, key string) response { t.Helper() raw, _ := json.Marshal(input) r := httptest.NewRequest(method, path, bytes.NewReader(raw)) r.Header.Set("Authorization", "Bearer "+token) r.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2") if version > 0 { r.Header.Set("If-Match", `"`+strconv.FormatInt(version, 10)+`"`) } if key != "" { r.Header.Set("Idempotency-Key", key) } w := httptest.NewRecorder() mux.ServeHTTP(w, r) if w.Code != status { t.Fatalf("%s %s got %d %s want %d", method, path, w.Code, w.Body.String(), status) } result := response{} if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil { t.Fatal(err) } return result } read := func() canvasModel { t.Helper() tx, e := db.BeginTx(ctx, nil) if e != nil { t.Fatal(e) } defer tx.Rollback() model, e := loadCanvasModel(ctx, tx, project, workspace, root) if e != nil { t.Fatal(e) } return model } mutate := func(edit func(*canvasModel)) { t.Helper() tx, e := db.BeginTx(ctx, nil) if e != nil { t.Fatal(e) } defer tx.Rollback() if _, _, e = lockMaterial(ctx, tx, project, workspace, root, account); e != nil { t.Fatal(e) } before, e := loadCanvasModel(ctx, tx, project, workspace, root) if e != nil { t.Fatal(e) } after := cloneModel(before) edit(&after) participants := map[string]bool{} for id := range after.Canvases { after.Versions[id] = before.Versions[id] + 1 participants[id] = true } for id := range before.Canvases { if _, active := after.Canvases[id]; !active { after.Versions[id] = before.Versions[id] + 1 participants[id] = true } } if e = validateCanvasModel(after); e != nil { t.Fatal(e) } if e = s.saveCanvasModel(queueRequest(ctx), tx, project, workspace, account, before, after, participants); e != nil { t.Fatal(e) } if e = tx.Commit(); e != nil { t.Fatal(e) } } migrationKey := modelTestID(6000) migration := call("POST", base(root)+"/model/migrate", response{"protocol_version": 2, "request_id": migrationKey, "expected_versions": map[string]int64{root: 1}}, 200, 0, migrationKey) node := "" for _, entry := range migration["identity_map"].([]any) { mapping := entry.(map[string]any) if mapping["sourceId"] == "a" { node = mapping["elementId"].(string) } } if node == "" { t.Fatal("missing migrated target") } mutate(func(model *canvasModel) { model.Elements[node]["geometry"].(map[string]any)["width"] = float64(9000) model.Elements[node]["opaque"] = map[string]any{"kept": true} model.Elements[node]["data"].(map[string]any)["extension"] = map[string]any{"constructor": map[string]any{"kept": true}} model.Elements["future"] = modelTestNode("future", root) model.Elements["future"]["componentId"] = "future-component" model.Elements["future"]["dataVersion"] = float64(12) }) next := 6100 command := func(board, target, model string, incarnation int64) (response, string) { next += 2 key := modelTestID(next) return response{"protocol_version": 2, "request_id": key, "operation_id": modelTestID(next + 1), "target_incarnation": incarnation, "expected_versions": func() map[string]int64 { model := read() versions := map[string]int64{} for id := range model.Canvases { versions[id] = model.Versions[id] } return versions }(), "node_id": target, "model_id": model, "prompt": "Generate", "parameters": response{}, "propagate": false}, key } start := func(board, target, model string, incarnation int64) response { input, key := command(board, target, model, incarnation) return call("POST", base(board)+"/ai/runs", input, 202, read().Versions[board], key) } execute := func(id string) { t.Helper() run, e := s.claimCanvasRun(ctx) if e != nil || run == nil || run.ID != id { t.Fatalf("claim %v %v", run, e) } s.executeCanvasRun(ctx, *run) } input, key := command(root, node, "text", 1) sourceVersion := read().Versions[root] admitted := call("POST", base(root)+"/ai/runs", input, 202, sourceVersion, key) if admitted["admission"] != "accepted" || admitted["target_incarnation"] != float64(1) || admitted["model"] == nil { t.Fatal("canonical admission lost identity/base") } retry := call("POST", base(root)+"/ai/runs", input, 202, sourceVersion, key) if !modelEqual(admitted, retry) { t.Fatal("admission retry changed result") } call("POST", base(root)+"/ai/runs", input, 409, sourceVersion+1, key) queried := call("GET", base(root)+"/ai/operations/"+key, nil, 200, 0, "") if !modelEqual(admitted, queried) { t.Fatal("lost admission response not recoverable") } unknown := call("GET", base(root)+"/ai/operations/"+modelTestID(6099), nil, 404, 0, "") if unknown["status"] != "unknown" || unknown["terminal"] == true { t.Fatal("404 pretended zero execution") } duplicate := response{} for k, v := range input { duplicate[k] = v } duplicateKey := modelTestID(6098) duplicate["request_id"] = duplicateKey call("POST", base(root)+"/ai/runs", duplicate, 409, read().Versions[root], duplicateKey) mutate(func(model *canvasModel) { model.Elements[node]["geometry"].(map[string]any)["x"] = float64(33) }) execute(admitted["run_id"].(string)) saved := read() data := saved.Elements[node]["data"].(map[string]any) if data["text"] != "generated result" || saved.Elements[node]["geometry"].(map[string]any)["x"] != float64(33) || saved.Elements[node]["geometry"].(map[string]any)["width"] != float64(9000) || saved.Elements["future"] == nil || saved.Elements[node]["opaque"] == nil || data["extension"] == nil { t.Fatal("AI lost canonical fields, geometry or future records") } // A content conflict retains its output; explicit application is still a narrow canonical write. conflictRun := start(root, node, "text", 1) hooks <- func() { mutate(func(model *canvasModel) { model.Elements[node]["data"].(map[string]any)["text"] = "user edit" }) } execute(conflictRun["run_id"].(string)) conflictPath := base(root) + "/ai/runs/" + conflictRun["run_id"].(string) conflict := call("GET", conflictPath, nil, 200, 0, "") if conflict["status"] != "conflict" { t.Fatal("changed content was overwritten") } outputID := conflict["outputs"].([]any)[0].(map[string]any)["output"].(map[string]any)["output_id"].(string) applyKey := modelTestID(6200) expected := read().Versions[root] applyInput := response{"protocol_version": 2, "request_id": applyKey, "operation_id": modelTestID(6199), "target_incarnation": 1, "target_canvas_id": root, "node_id": node, "output_id": outputID} applied := call("POST", conflictPath+"/apply", applyInput, 200, expected, applyKey) again := call("POST", conflictPath+"/apply", applyInput, 200, expected, applyKey) if !modelEqual(applied, again) || applied["model"] == nil || read().Elements[node]["geometry"].(map[string]any)["width"] != float64(9000) { t.Fatal("explicit canonical application changed geometry or receipt") } applyReceipt := call("GET", base(root)+"/ai/operations/"+applyKey, nil, 200, 0, "") if !modelEqual(applied, applyReceipt) || applied["action"] != "run.apply" || applied["status"] != "applied" { t.Fatal("explicit apply receipt is not recoverable") } call("POST", conflictPath+"/apply", applyInput, 409, expected+1, applyKey) // Keep one unapplied old output, then replace the target incarnation atomically. stale := start(root, node, "text", 1) hooks <- func() { mutate(func(model *canvasModel) { model.Elements[node]["data"].(map[string]any)["text"] = "keep this" }) } execute(stale["run_id"].(string)) stalePath := base(root) + "/ai/runs/" + stale["run_id"].(string) staleResult := call("GET", stalePath, nil, 200, 0, "") staleOutput := staleResult["outputs"].([]any)[0].(map[string]any)["output"].(map[string]any)["output_id"].(string) old := start(root, node, "text", 1) run, e := s.claimCanvasRun(ctx) if e != nil || run == nil || run.ID != old["run_id"] { t.Fatalf("claim stale %v", e) } if ok, e := s.startCanvasStep(ctx, *run, run.Plan.Steps[0]); e != nil || !ok { t.Fatalf("start stale %v", e) } mutate(func(model *canvasModel) { model.Elements[node]["incarnation"] = float64(2) model.Tombstones[node] = 1 model.TombstoneOwners[node] = root }) state, e := s.finishCanvasStep(ctx, *run, run.Plan.Steps[0], "late output", "", true) if e != nil || state != "cancelled" { t.Fatalf("restored target accepted old callback %s %v", state, e) } if e = s.completeCanvasRun(ctx, *run, nil); e != nil { t.Fatal(e) } if read().Elements[node]["data"].(map[string]any)["text"] != "keep this" { t.Fatal("restore was overwritten") } staleApplyKey := modelTestID(6201) staleApply := call("POST", stalePath+"/apply", response{"protocol_version": 2, "request_id": staleApplyKey, "operation_id": modelTestID(6205), "target_incarnation": 1, "target_canvas_id": root, "node_id": node, "output_id": staleOutput}, 409, read().Versions[root], staleApplyKey) if staleApply["status"] != "not-applied" || staleApply["terminal"] != true || !modelEqual(staleApply, call("GET", base(root)+"/ai/operations/"+staleApplyKey, nil, 200, 0, "")) { t.Fatal("stale apply has no queryable zero-effect receipt") } bad, badKey := command(root, node, "text", 1) call("POST", base(root)+"/ai/runs", bad, 409, read().Versions[root], badKey) restored := start(root, node, "text", 2) cancelPath := base(root) + "/ai/runs/" + restored["run_id"].(string) + "/cancel" cancelKey := modelTestID(6202) cancelInput := response{"protocol_version": 2, "request_id": cancelKey, "operation_id": modelTestID(6203)} cancelled := call("POST", cancelPath, cancelInput, 200, 0, cancelKey) cancelAgain := call("POST", cancelPath, cancelInput, 200, 0, cancelKey) cancelReceipt := call("GET", base(root)+"/ai/operations/"+cancelKey, nil, 200, 0, "") if cancelled["status"] != "applied" || cancelled["run_status"] != "cancelled" || !modelEqual(cancelled, cancelAgain) || !modelEqual(cancelled, cancelReceipt) { t.Fatal("cancel receipt changed on retry/query") } duplicateCancelKey := modelTestID(6204) call("POST", cancelPath, response{"protocol_version": 2, "request_id": duplicateCancelKey, "operation_id": modelTestID(6203)}, 409, 0, duplicateCancelKey) if executions.Load() != 3 { t.Fatal("duplicate/cancelled/old execution called the model") } // Image output resolves a managed resource while retaining the element envelope. imageID := modelTestID(6300) mutate(func(model *canvasModel) { record := modelTestNode(imageID, root) record["componentId"] = "plain-image" record["data"].(map[string]any)["src"] = "data:image/png;base64," + base64.StdEncoding.EncodeToString(pngBytes.Bytes()) record["geometry"].(map[string]any)["width"] = float64(10000) model.Elements[imageID] = record }) imageRun := start(root, imageID, "image", 1) execute(imageRun["run_id"].(string)) imageRecord := read().Elements[imageID] imageData := imageRecord["data"].(map[string]any) if imageRecord["geometry"].(map[string]any)["width"] != float64(10000) || imageData["assetId"] == nil || !strings.HasPrefix(modelString(imageData["src"]), s.assetURL(project, workspace, "")) { t.Fatal("image result lost geometry or resource identity") } request := httptest.NewRequest("GET", modelString(imageData["src"]), nil) request.Header.Set("Authorization", "Bearer "+token) download := httptest.NewRecorder() mux.ServeHTTP(download, request) if download.Code != 200 || !bytes.Equal(download.Body.Bytes(), pngBytes.Bytes()) { t.Fatal("canonical generated asset is unreadable") } moved := start(root, imageID, "image", 1) moving, e := s.claimCanvasRun(ctx) if e != nil || moving == nil || moving.ID != moved["run_id"] { t.Fatalf("claim move %v", e) } if ok, e := s.startCanvasStep(ctx, *moving, moving.Plan.Steps[0]); e != nil || !ok { t.Fatalf("start move %v", e) } child, frame := modelTestID(6301), modelTestID(6302) mutate(func(model *canvasModel) { entry := modelTestNode(frame, root) entry["componentId"] = "frame" model.Elements[frame] = entry model.Canvases[child] = modelCanvas{ID: child, Parent: &modelParent{CanvasID: root, EntryElementID: frame}} model.Elements[imageID]["ownerCanvasId"] = child }) busyInput, busyKey := command(child, imageID, "image", 1) busy := call("POST", base(child)+"/ai/runs", busyInput, 409, read().Versions[child], busyKey) if busy["error"] != "node_busy" { t.Fatal("owner move admitted a duplicate paid task") } beforeMovedOutput := read() state, e = s.finishCanvasStepOutput(ctx, *moving, moving.Plan.Steps[0], codex.CanvasOutput{Kind: "image", Image: &codex.CanvasImage{MIME: "image/png", Data: pngBytes.Bytes()}}, "", true) if e != nil || state != "succeeded" { t.Fatalf("owner-only move rejected output %s %v", state, e) } afterMovedOutput := read() if afterMovedOutput.Elements[imageID]["ownerCanvasId"] != child || afterMovedOutput.Versions[root] != beforeMovedOutput.Versions[root] || afterMovedOutput.Versions[child] != beforeMovedOutput.Versions[child]+1 || afterMovedOutput.Elements[imageID]["geometry"].(map[string]any)["width"] != float64(10000) { t.Fatal("relocated result rewrote ownership, geometry or the origin version") } movedStatus := call("GET", base(root)+"/ai/runs/"+moving.ID, nil, 200, 0, "") foundRelocation := false for _, value := range movedStatus["events"].([]any) { event := value.(map[string]any) if event["type"] == "step.applied" { foundRelocation = event["board_id"] == child && event["origin_board_id"] == root && event["canonical_root"] == root && event["model"].(map[string]any)["complete"] == true } } if !foundRelocation || movedStatus["applied_versions"].(map[string]any)[child] != float64(afterMovedOutput.Versions[child]) { t.Fatal("moved output lost current-owner version or canonical context") } if e = s.completeCanvasRun(ctx, *moving, nil); e != nil { t.Fatal(e) } staleInput, staleKey := command(child, imageID, "image", 1) staleVersions := staleInput["expected_versions"].(map[string]int64) staleVersions[root]-- // The target version is current; its ancestor context is not. beforeRejected := read() denied := call("POST", base(child)+"/ai/runs", staleInput, 412, read().Versions[child], staleKey) if denied["status"] != "not-applied" || denied["terminal"] != true || denied["action"] != "run.start" || !modelEqual(beforeRejected, read()) { t.Fatal("rejection was not a zero-effect receipt") } if queried := call("GET", base(child)+"/ai/operations/"+staleKey, nil, 200, 0, ""); !modelEqual(denied, queried) { t.Fatal("negative admission receipt lost") } // A later context change cannot turn an old rejected key into a paid execution. mutate(func(model *canvasModel) { model.Elements[imageID]["geometry"].(map[string]any)["x"] = float64(123) }) if retried := call("POST", base(child)+"/ai/runs", staleInput, 412, beforeRejected.Versions[child], staleKey); !modelEqual(denied, retried) { t.Fatal("rejected request was reevaluated") } missingRunKey := modelTestID(6400) missingCancel := call("POST", base(child)+"/ai/runs/"+modelTestID(6401)+"/cancel", response{"protocol_version": 2, "request_id": missingRunKey, "operation_id": modelTestID(6402)}, 404, 0, missingRunKey) if missingCancel["status"] != "not-applied" || missingCancel["terminal"] != true { t.Fatal("missing run cancel has no stable rejection") } if queried := call("GET", base(child)+"/ai/operations/"+missingRunKey, nil, 200, 0, ""); !modelEqual(missingCancel, queried) { t.Fatal("negative cancel receipt lost") } missingInput, missingKey := command(child, imageID, "image", 1) delete(missingInput, "expected_versions") call("POST", base(child)+"/ai/runs", missingInput, 400, read().Versions[child], missingKey) // An explicit replan can reuse a logical operation after its known zero-effect rejection. replanned := response{} for key, value := range staleInput { replanned[key] = value } replanKey := modelTestID(6405) replanned["request_id"], replanned["expected_versions"] = replanKey, read().Versions childRun := call("POST", base(child)+"/ai/runs", replanned, 202, read().Versions[child], replanKey) execute(childRun["run_id"].(string)) beforeLateCancel := read() lateKey := modelTestID(6406) lateCancel := call("POST", base(child)+"/ai/runs/"+childRun["run_id"].(string)+"/cancel", response{"protocol_version": 2, "request_id": lateKey, "operation_id": modelTestID(6407)}, 200, 0, lateKey) if lateCancel["run_status"] != "succeeded" || !modelEqual(beforeLateCancel, read()) { t.Fatal("late cancellation pretended to undo a completed result") } if read().Elements[imageID]["ownerCanvasId"] != child { t.Fatal("child result moved its target back") } queuedMove := start(child, imageID, "image", 1) mutate(func(model *canvasModel) { model.Elements[imageID]["ownerCanvasId"] = root delete(model.Canvases, child) }) execute(queuedMove["run_id"].(string)) archivedRoute := base(child) + "/ai/runs/" + queuedMove["run_id"].(string) archivedResult := call("GET", archivedRoute, nil, 200, 0, "") if archivedResult["status"] != "succeeded" || read().Elements[imageID]["ownerCanvasId"] != root { t.Fatal("queued move or archived admission route stopped the run") } lateArchiveKey := modelTestID(6500) if result := call("POST", archivedRoute+"/cancel", response{"protocol_version": 2, "request_id": lateArchiveKey, "operation_id": modelTestID(6501)}, 200, 0, lateArchiveKey); result["run_status"] != "succeeded" { t.Fatal("archived route lost cancellation identity") } // Content changes still conflict after a move; explicit application targets the current owner. movedConflict := start(root, node, "text", 2) hooks <- func() { mutate(func(model *canvasModel) { model.Canvases[child] = modelCanvas{ID: child, Parent: &modelParent{CanvasID: root, EntryElementID: frame}} model.Elements[node]["ownerCanvasId"] = child model.Elements[node]["data"].(map[string]any)["text"] = "keep moved edit" }) } execute(movedConflict["run_id"].(string)) movedConflictPath := base(root) + "/ai/runs/" + movedConflict["run_id"].(string) conflictMovedResult := call("GET", movedConflictPath, nil, 200, 0, "") if conflictMovedResult["status"] != "conflict" || read().Elements[node]["data"].(map[string]any)["text"] != "keep moved edit" { t.Fatal("move allowed a content conflict overwrite") } movedOutput := conflictMovedResult["outputs"].([]any)[0].(map[string]any)["output"].(map[string]any)["output_id"].(string) movedApplyKey := modelTestID(6502) movedApplied := call("POST", movedConflictPath+"/apply", response{"protocol_version": 2, "request_id": movedApplyKey, "operation_id": modelTestID(6503), "node_id": node, "output_id": movedOutput, "target_incarnation": 2, "target_canvas_id": child}, 200, read().Versions[child], movedApplyKey) if movedApplied["board_id"] != child || movedApplied["origin_board_id"] != root || read().Elements[node]["ownerCanvasId"] != child { t.Fatal("explicit application wrote to the frozen owner") } doomed := start(child, node, "text", 2) mutate(func(model *canvasModel) { record := model.Elements[node] model.DeadRecords[node] = record model.Tombstones[node] = 2 model.TombstoneOwners[node] = child delete(model.Elements, node) for id, element := range model.Elements { if element["structure"] == "connection" && (element["source"].(map[string]any)["elementId"] == node || element["target"].(map[string]any)["elementId"] == node) { model.DeadRecords[id] = element model.Tombstones[id] = modelInt(element["incarnation"]) model.TombstoneOwners[id] = modelString(element["ownerCanvasId"]) delete(model.Elements, id) } } }) execute(doomed["run_id"].(string)) if result := call("GET", base(child)+"/ai/runs/"+doomed["run_id"].(string), nil, 200, 0, ""); result["status"] != "cancelled" { t.Fatal("deleting a moved target failed to revoke its old job") } revoked := start(root, imageID, "image", 1) mutate(func(model *canvasModel) { model.Elements[imageID]["ownerCanvasId"] = child }) beforeRevoked := executions.Load() if _, e = db.ExecContext(ctx, `UPDATE workspace_members SET role='viewer' WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, project, workspace, account); e != nil { t.Fatal(e) } execute(revoked["run_id"].(string)) if result := call("GET", base(root)+"/ai/runs/"+revoked["run_id"].(string), nil, 200, 0, ""); result["status"] != "failed" || executions.Load() != beforeRevoked { t.Fatal("moved target executed after write permission was revoked") } }