// Canonical 原子性数据库回归:需 PLATFORM_TEST_DATABASE_URL 指向隔离且已迁移测试库,未配置则跳过。 package platform import ( "bytes" "context" "crypto/rand" "crypto/sha256" "database/sql" "encoding/base64" "encoding/hex" "encoding/json" "net/http" "net/http/httptest" "os" "testing" "time" ) // canonicalAtomicFixture 持有随机项目、真实路由与源快照,所有请求共用有效账户和独立工作区。 type canonicalAtomicFixture struct { db *sql.DB mux *http.ServeMux project, account, workspace, root, token string legacy json.RawMessage } // newCanonicalAtomicFixture 建账户/会话/admin/旧图,并按外键关系注册数据清理;不自动执行迁移脚本。 func newCanonicalAtomicFixture(t *testing.T) *canonicalAtomicFixture { t.Helper() 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) } t.Cleanup(func() { db.Close() }) var entropy [12]byte _, _ = rand.Read(entropy[:]) f := &canonicalAtomicFixture{db: db, project: "canonical-atomic-" + hex.EncodeToString(entropy[:])} ctx := context.Background() t.Cleanup(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_subgraphs", "workspaces", "project_accounts"} { _, _ = db.ExecContext(ctx, "DELETE FROM "+table+" WHERE project=$1", f.project) } }) if err = db.QueryRowContext(ctx, `INSERT INTO project_accounts(project,id) VALUES($1,gen_random_uuid()) RETURNING id::text`, f.project).Scan(&f.account); err != nil { t.Fatal(err) } var tokenBytes [32]byte _, _ = rand.Read(tokenBytes[:]) f.token = base64.RawURLEncoding.EncodeToString(tokenBytes[:]) hash := sha256.Sum256([]byte(f.token)) 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(hash[:]), f.project, f.account); err != nil { t.Fatal(err) } if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Canonical atomic',$2) RETURNING id::text`, f.project, f.account).Scan(&f.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')`, f.project, f.workspace, f.account); err != nil { t.Fatal(err) } f.legacy = json.RawMessage(`{"schema_version":1,"nodes":[` + modelLegacyFrame + `,{"id":"a","type":"material","position":{"x":150,"y":260},"width":240,"height":72,"data":{"kind":"text","title":"a","text":"preserved","frameId":"f"}},{"id":"b","type":"material","position":{"x":180,"y":300},"width":240,"height":72,"data":{"kind":"text","title":"b","text":"preserved","frameId":"f"}},{"id":"c","type":"material","position":{"x":0,"y":0},"width":240,"height":72,"data":{"kind":"text","title":"c","text":"unrelated"}}],"edges":[{"id":"e","source":"a","target":"b"}],"viewport":{"x":0,"y":0,"zoom":1}}`) if err = db.QueryRowContext(ctx, `INSERT INTO materials(project,workspace_id,kind,title,created_by,canvas_document) VALUES($1,$2,'board','Root',$3,$4) RETURNING id::text`, f.project, f.workspace, f.account, f.legacy).Scan(&f.root); err != nil { t.Fatal(err) } f.mux = http.NewServeMux() Register(f.mux, db, map[string]string{f.project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil) return f } // path 返回本 fixture 根的 canonical 入口,避免测试错用旧快照路径。 func (f *canonicalAtomicFixture) path() string { return "/projects/" + f.project + "/workspaces/" + f.workspace + "/materials/" + f.root + "/canvas/model" } // request 携带会话、预期账户及 v2 协商,并沿用传入 context 以测试数据库写入中途取消。 func (f *canonicalAtomicFixture) request(ctx context.Context, method, path, key string, raw []byte) *httptest.ResponseRecorder { r := httptest.NewRequest(method, path, bytes.NewReader(raw)).WithContext(ctx) r.Header.Set("Authorization", "Bearer "+f.token) r.Header.Set("X-Expected-Account", f.account) r.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2") if key != "" { r.Header.Set("Idempotency-Key", key) } w := httptest.NewRecorder() f.mux.ServeHTTP(w, r) return w } // canonicalAtomicResponse 先断言实际 HTTP 状态,再解码响应,避免把错误 JSON 当作正常模型使用。 func canonicalAtomicResponse(t *testing.T, w *httptest.ResponseRecorder, status int) response { t.Helper() if w.Code != status { t.Fatalf("canonical response got %d %s want %d", w.Code, w.Body.String(), status) } var body response if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil { t.Fatal(err) } return body } // read 直接从权威模型表装配完整模型,检查 HTTP 应答外的持久化事实。 func (f *canonicalAtomicFixture) read(t *testing.T) canvasModel { t.Helper() tx, err := f.db.BeginTx(context.Background(), nil) if err != nil { t.Fatal(err) } defer tx.Rollback() model, err := loadCanvasModel(context.Background(), tx, f.project, f.workspace, f.root) if err != nil { t.Fatal(err) } return model } // concurrent 同时放行多请求并按原索引收集,二十秒上下文限制等待,不以返回顺序猜赢家。 func (f *canonicalAtomicFixture) concurrent(t *testing.T, path string, keys []string, bodies [][]byte) []*httptest.ResponseRecorder { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) defer cancel() type result struct { index int writer *httptest.ResponseRecorder } start, done := make(chan struct{}), make(chan result, len(keys)) for i := range keys { go func(index int) { <-start done <- result{index, f.request(ctx, "POST", path, keys[index], bodies[index])} }(i) } close(start) out := make([]*httptest.ResponseRecorder, len(keys)) for range keys { select { case value := <-done: out[value.index] = value.writer case <-ctx.Done(): t.Fatal("canonical concurrent requests did not finish") } } return out } // TestCanonicalConcurrentMigrationAndOwnershipWrites 验证同键迁移/编辑只执行一次,不同条件所有权写只有一个赢家。 // 成功和冲突都必须有可查询冻结回执,未涉及元素和树不得被部分改写。 func TestCanonicalConcurrentMigrationAndOwnershipWrites(t *testing.T) { f := newCanonicalAtomicFixture(t) ctx := context.Background() key := modelTestID(8000) input := response{"protocol_version": 2, "request_id": key, "expected_versions": map[string]int64{f.root: 1}} raw := modelJSON(input) replies := f.concurrent(t, f.path()+"/migrate", []string{key, key, key, key}, [][]byte{raw, raw, raw, raw}) first := canonicalAtomicResponse(t, replies[0], 200) for _, reply := range replies[1:] { if !modelEqual(first, canonicalAtomicResponse(t, reply, 200)) { t.Fatal("concurrent migration allocated different identities or receipts") } } ids := map[string]string{} for _, value := range first["identity_map"].([]any) { mapping := value.(map[string]any) ids[mapping["sourceId"].(string)] = mapping["elementId"].(string) } before := f.read(t) child := modelString(before.Elements[ids["a"]]["ownerCanvasId"]) if len(before.Canvases) != 2 || len(ids) != 5 || child == f.root || before.Versions[f.root] != 2 || before.Versions[child] != 1 { t.Fatal("concurrent migration duplicated the implicit partition or version barrier") } key = modelTestID(8001) edit := modelBatch{ProtocolVersion: 2, RequestID: key, Expected: map[string]int64{child: 1}, Operations: []modelOperation{{ID: modelTestID(8002), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: ids["a"], Incarnation: 1}, Field: "data.title", Before: modelJSON("a"), After: modelJSON("renamed")}}}}} raw = modelJSON(edit) replies = f.concurrent(t, f.path()+"/operations", []string{key, key, key, key}, [][]byte{raw, raw, raw, raw}) first = canonicalAtomicResponse(t, replies[0], 200) for _, reply := range replies[1:] { if !modelEqual(first, canonicalAtomicResponse(t, reply, 200)) { t.Fatal("concurrent edit retry changed its original receipt") } } before = f.read(t) if before.Versions[child] != 2 || before.Versions[f.root] != 2 || modelString(before.Elements[ids["a"]]["data"].(map[string]any)["title"]) != "renamed" { t.Fatal("concurrent edit executed more than once") } // 两请求共享同一版本向量,各移动不同节点但都移动其连接,验证条件写竞争而非简单串行重放。 var batches []modelBatch var keys []string var bodies [][]byte for index, node := range []string{ids["a"], ids["b"]} { key := modelTestID(8100 + index) batch := modelBatch{ProtocolVersion: 2, RequestID: key, Expected: map[string]int64{f.root: 2, child: 2}, Operations: []modelOperation{{ID: modelTestID(8200 + index), Changes: []modelChange{ {Kind: "field", Target: modelTarget{ID: node, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(child), After: modelJSON(f.root)}, {Kind: "field", Target: modelTarget{ID: ids["e"], Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(child), After: modelJSON(f.root)}, }}}} batches, keys, bodies = append(batches, batch), append(keys, key), append(bodies, modelJSON(batch)) } replies = f.concurrent(t, f.path()+"/operations", keys, bodies) winner, successes := -1, 0 for index, reply := range replies { status := 412 if reply.Code == 200 { winner, successes, status = index, successes+1, 200 } body := canonicalAtomicResponse(t, reply, status) queried := canonicalAtomicResponse(t, f.request(ctx, "GET", f.path()+"/operations/"+keys[index], "", nil), 200) if !modelEqual(body, queried) || status == 412 && (body["status"] != "not-applied" || body["terminal"] != true || body["error"] != "version_conflict") { t.Fatal("a competing write lost its queryable applied or zero-effect receipt") } } if successes != 1 { t.Fatal("competing conditional ownership writes did not have exactly one winner") } after := f.read(t) if err := validateCanvasModel(after); err != nil { t.Fatal(err) } nodes := []string{ids["a"], ids["b"]} if after.Versions[f.root] != 3 || after.Versions[child] != 3 || modelString(after.Elements[nodes[winner]]["ownerCanvasId"]) != f.root || modelString(after.Elements[nodes[1-winner]]["ownerCanvasId"]) != child || modelString(after.Elements[ids["e"]]["ownerCanvasId"]) != f.root || !modelEqual(before.Elements[ids["c"]], after.Elements[ids["c"]]) || !modelEqual(before.Canvases, after.Canvases) { t.Fatal("competing ownership writes published a partial node/edge/tree or advanced versions twice") } var count int if err := f.db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_model_operations WHERE project=$1`, f.project).Scan(&count); err != nil || count != 2 { t.Fatalf("logical operations: %d %v", count, err) } changed := batches[winner] changed.Operations[0].ID = modelTestID(8999) body := canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/operations", keys[winner], modelJSON(changed)), 409) if body["error"] != "idempotency_conflict" || !modelEqual(after, f.read(t)) { t.Fatal("same key with different bytes changed the canonical model") } } // TestCanonicalMigrationLateCancellationRollsBack 用独占表锁卡住后期身份映射 INSERT,观察确实到达后才取消请求。 // 所有模型/关系/新素材和旧版本应回滚,随后同原请求能安全重试且只分配一次最终身份映射。 func TestCanonicalMigrationLateCancellationRollsBack(t *testing.T) { f := newCanonicalAtomicFixture(t) ctx, stop := context.WithTimeout(context.Background(), 20*time.Second) defer stop() barrier, err := f.db.BeginTx(ctx, nil) if err != nil { t.Fatal(err) } defer barrier.Rollback() if _, err = barrier.ExecContext(ctx, `LOCK TABLE canvas_model_identity_map IN ACCESS EXCLUSIVE MODE`); err != nil { t.Fatal(err) } var blocker int if err = barrier.QueryRowContext(ctx, `SELECT pg_backend_pid()`).Scan(&blocker); err != nil { t.Fatal(err) } key := modelTestID(8300) input := response{"protocol_version": 2, "request_id": key, "expected_versions": map[string]int64{f.root: 1}} requestContext, cancel := context.WithCancel(ctx) defer cancel() done := make(chan *httptest.ResponseRecorder, 1) go func() { done <- f.request(requestContext, "POST", f.path()+"/migrate", key, modelJSON(input)) }() // Observe the actual late INSERT blocked behind this transaction. A timer // alone cannot prove migration reached canonical/material/subgraph writes. // 查询 pg_stat_activity/pg_blocking_pids 证明是目标后期写被阻塞,不用单纯 sleep 推断执行进度。 ticker := time.NewTicker(10 * time.Millisecond) defer ticker.Stop() observed := false for !observed { if err = f.db.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE usename=current_user AND query LIKE 'INSERT INTO canvas_model_identity_map%' AND $1=ANY(pg_blocking_pids(pid)))`, blocker).Scan(&observed); err != nil { t.Fatal(err) } if observed { break } select { case reply := <-done: t.Fatalf("migration did not reach its late write: %d %s", reply.Code, reply.Body.String()) case <-ctx.Done(): t.Fatal("migration never reached its late identity-map INSERT") case <-ticker.C: } } cancel() select { case reply := <-done: canonicalAtomicResponse(t, reply, 503) case <-ctx.Done(): t.Fatal("cancelled migration did not finish") } if err = barrier.Rollback(); err != nil { t.Fatal(err) } for _, table := range []string{"canvas_model_projects", "canvas_model_canvases", "canvas_model_elements", "canvas_model_identity_map", "canvas_model_requests", "canvas_model_operations", "canvas_subgraphs"} { var count int if err = f.db.QueryRowContext(ctx, "SELECT count(*) FROM "+table+" WHERE project=$1", f.project).Scan(&count); err != nil || count != 0 { t.Fatalf("late cancellation left %s rows: %d %v", table, count, err) } } var count int var version int64 var source json.RawMessage if err = f.db.QueryRowContext(ctx, `SELECT count(*) FROM materials WHERE project=$1`, f.project).Scan(&count); err != nil || count != 1 { t.Fatalf("synthetic partition material survived rollback: %d %v", count, err) } if err = f.db.QueryRowContext(ctx, `SELECT canvas_version,canvas_document FROM materials WHERE project=$1 AND id=$2`, f.project, f.root).Scan(&version, &source); err != nil || version != 1 || !modelEqual(f.legacy, source) { t.Fatalf("late cancellation changed legacy source/version: %d %v", version, err) } // Infrastructure failure saved no result. The same original request can be // retried safely, and all subsequent retries must return its one identity map. first := canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/migrate", key, modelJSON(input)), 200) retry := canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/migrate", key, modelJSON(input)), 200) if !modelEqual(first, retry) || len(f.read(t).Canvases) != 2 { t.Fatal("retry after rollback duplicated identities or the implicit partition") } } // TestCanonicalMigrationPermissionVersionAndRunGuards 检查 viewer、陈旧版本及 queued/running AI 阻止身份屏障。 // 原拒绝键在版本或任务状态改变后仍冻结,新的请求键才能在条件满足后执行迁移。 func TestCanonicalMigrationPermissionVersionAndRunGuards(t *testing.T) { f := newCanonicalAtomicFixture(t) ctx := context.Background() input := func(key string, version int64) response { return response{"protocol_version": 2, "request_id": key, "expected_versions": map[string]int64{f.root: version}} } call := func(key string, version int64, status int) response { t.Helper() return canonicalAtomicResponse(t, f.request(ctx, "POST", f.path()+"/migrate", key, modelJSON(input(key, version))), status) } assertLegacy := func(version int64) { t.Helper() for _, table := range []string{"canvas_model_projects", "canvas_model_canvases", "canvas_model_elements", "canvas_model_identity_map", "canvas_subgraphs"} { var count int if err := f.db.QueryRowContext(ctx, "SELECT count(*) FROM "+table+" WHERE project=$1", f.project).Scan(&count); err != nil || count != 0 { t.Fatalf("rejected migration left %s rows: %d %v", table, count, err) } } var count int var current int64 var source json.RawMessage if err := f.db.QueryRowContext(ctx, `SELECT count(*) FROM materials WHERE project=$1`, f.project).Scan(&count); err != nil || count != 1 { t.Fatalf("rejected migration created a material: %d %v", count, err) } if err := f.db.QueryRowContext(ctx, `SELECT canvas_version,canvas_document FROM materials WHERE project=$1 AND id=$2`, f.project, f.root).Scan(¤t, &source); err != nil || current != version || !modelEqual(f.legacy, source) { t.Fatalf("rejected migration changed legacy source/version: %d %v", current, err) } } if _, err := f.db.ExecContext(ctx, `UPDATE workspace_members SET role='viewer' WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, f.project, f.workspace, f.account); err != nil { t.Fatal(err) } if call(modelTestID(8500), 1, 403)["error"] != "forbidden" { t.Fatal("viewer crossed the identity migration barrier") } assertLegacy(1) if _, err := f.db.ExecContext(ctx, `UPDATE workspace_members SET role='admin' WHERE project=$1 AND workspace_id=$2 AND account_id=$3`, f.project, f.workspace, f.account); err != nil { t.Fatal(err) } staleKey := modelTestID(8501) rejected := call(staleKey, 2, 412) if rejected["status"] != "not-applied" || rejected["terminal"] != true || rejected["error"] != "migration_version_conflict" { t.Fatal("stale source migration did not produce a zero-effect receipt") } assertLegacy(1) // Advance the old writer to the formerly rejected expected version. That // cannot turn the same frozen negative request into a migration later. if _, err := f.db.ExecContext(ctx, `UPDATE materials SET canvas_version=2 WHERE project=$1 AND id=$2`, f.project, f.root); err != nil { t.Fatal(err) } if !modelEqual(rejected, call(staleKey, 2, 412)) { t.Fatal("a source version change reevaluated a rejected migration key") } assertLegacy(2) run := modelTestID(8400) if _, err := f.db.ExecContext(ctx, `INSERT INTO canvas_ai_runs(project,workspace_id,board_id,id,account_id,idempotency_key,payload_hash,status,plan,create_response) VALUES($1,$2,$3,$4,$5,$6,'fixture','queued','{}','{}')`, f.project, f.workspace, f.root, run, f.account, modelTestID(8401)); err != nil { t.Fatal(err) } if _, err := f.db.ExecContext(ctx, `INSERT INTO canvas_ai_steps(project,workspace_id,run_id,id,board_id,node_id,ordinal,status,model_id,frozen_input,target_fingerprint) VALUES($1,$2,$3,'fixture',$4,'a',0,'queued','fixture','{}','fixture')`, f.project, f.workspace, run, f.root); err != nil { t.Fatal(err) } for index, status := range []string{"queued", "running"} { if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_runs SET status=$4 WHERE project=$1 AND workspace_id=$2 AND id=$3`, f.project, f.workspace, run, status); err != nil { t.Fatal(err) } if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_steps SET status=$4 WHERE project=$1 AND workspace_id=$2 AND run_id=$3`, f.project, f.workspace, run, status); err != nil { t.Fatal(err) } body := call(modelTestID(8600+index), 2, 409) if body["status"] != "not-applied" || body["terminal"] != true || body["error"] != "migration_waiting_for_runs" { t.Fatal("identity migration crossed queued or outcome-unknown execution") } assertLegacy(2) } if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_steps SET status='cancelled' WHERE project=$1 AND workspace_id=$2 AND run_id=$3`, f.project, f.workspace, run); err != nil { t.Fatal(err) } if _, err := f.db.ExecContext(ctx, `UPDATE canvas_ai_runs SET status='cancelled' WHERE project=$1 AND workspace_id=$2 AND id=$3`, f.project, f.workspace, run); err != nil { t.Fatal(err) } if call(modelTestID(8601), 2, 409)["error"] != "migration_waiting_for_runs" { t.Fatal("settling paid work changed the frozen rejection") } call(modelTestID(8602), 2, 200) model := f.read(t) if model.Versions[f.root] != 3 || len(model.Canvases) != 2 { t.Fatal("explicit migration after execution settled lost its source version barrier") } }