399 lines
25 KiB
Go
399 lines
25 KiB
Go
package platform
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
func TestCanonicalModelMigrationAndIncrementalLifecycle(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 [12]byte
|
|
_, _ = rand.Read(entropy[:])
|
|
project := "canonical-" + hex.EncodeToString(entropy[:])
|
|
defer func() {
|
|
for _, table := range []string{"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", project)
|
|
}
|
|
}()
|
|
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)
|
|
}
|
|
var tokenBytes [32]byte
|
|
_, _ = rand.Read(tokenBytes[:])
|
|
token := base64.RawURLEncoding.EncodeToString(tokenBytes[:])
|
|
hash := sha256.Sum256([]byte(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[:]), project, account); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = db.QueryRowContext(ctx, `INSERT INTO workspaces(project,name,owner_id) VALUES($1,'Canonical',$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)
|
|
}
|
|
legacy := json.RawMessage(`{"schema_version":1,"nodes":[` + modelLegacyFrame + `,{"id":"a","type":"plainText","position":{"x":150,"y":260},"width":240,"height":72,"data":{"kind":"plain-text","title":"a","text":"preserved","frameId":"f"}}],"edges":[],"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`, project, workspace, account, legacy).Scan(&root); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mux := http.NewServeMux()
|
|
Register(mux, db, map[string]string{project: "https://app.example.com/auth/callback"}, "https://api.example.com", nil)
|
|
base := "/projects/" + project + "/workspaces/" + workspace + "/materials/" + root + "/canvas"
|
|
call := func(method, path string, input any, key string, status int) response {
|
|
t.Helper()
|
|
raw, _ := json.Marshal(input)
|
|
request := httptest.NewRequest(method, path, bytes.NewReader(raw))
|
|
request.Header.Set("Authorization", "Bearer "+token)
|
|
request.Header.Set("Accept", "application/vnd.foundry.canvas+json;version=2")
|
|
if key != "" {
|
|
request.Header.Set("Idempotency-Key", key)
|
|
}
|
|
writer := httptest.NewRecorder()
|
|
mux.ServeHTTP(writer, request)
|
|
if writer.Code != status {
|
|
t.Fatalf("%s %s got %d %s want %d", method, path, writer.Code, writer.Body.String(), status)
|
|
}
|
|
out := response{}
|
|
if writer.Body.Len() > 0 {
|
|
if err := json.Unmarshal(writer.Body.Bytes(), &out); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
read := func() canvasModel {
|
|
t.Helper()
|
|
tx, err := db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer tx.Rollback()
|
|
model, err := loadCanvasModel(ctx, tx, project, workspace, root)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return model
|
|
}
|
|
if call("GET", base+"/model", nil, "", 409)["error"] != "canonical_migration_required" {
|
|
t.Fatal("legacy read silently migrated")
|
|
}
|
|
var count int
|
|
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_model_projects WHERE project=$1`, project).Scan(&count); err != nil || count != 0 {
|
|
t.Fatal("GET created a canonical project")
|
|
}
|
|
migrationKey := modelTestID(1000)
|
|
migrationInput := response{"protocol_version": 2, "request_id": migrationKey, "expected_versions": map[string]int64{root: 1}}
|
|
migration := call("POST", base+"/model/migrate", migrationInput, migrationKey, 200)
|
|
if migration["status"] != "applied" {
|
|
t.Fatal("migration missing applied receipt")
|
|
}
|
|
retry := call("POST", base+"/model/migrate", migrationInput, migrationKey, 200)
|
|
if !modelEqual(migration["identity_map"], retry["identity_map"]) {
|
|
t.Fatal("migration retry allocated a second identity map")
|
|
}
|
|
identities := migration["identity_map"].([]any)
|
|
nodeID, frameID := "", ""
|
|
for _, item := range identities {
|
|
mapping := item.(map[string]any)
|
|
switch mapping["sourceId"] {
|
|
case "a":
|
|
nodeID = mapping["elementId"].(string)
|
|
case "f":
|
|
frameID = mapping["elementId"].(string)
|
|
}
|
|
}
|
|
model := read()
|
|
if nodeID == "" || frameID == "" || len(model.Canvases) != 2 {
|
|
t.Fatal("migration lost identities or an implicit partition")
|
|
}
|
|
child := modelString(model.Elements[nodeID]["ownerCanvasId"])
|
|
if child == root || model.Canvases[child].Parent.EntryElementID != frameID || model.Versions[root] != 2 || model.Versions[child] != 1 {
|
|
t.Fatal("canonical owning tree or version barrier is incorrect")
|
|
}
|
|
if call("PATCH", base, response{"document": legacy}, "", 409)["error"] != "canonical_write_required" {
|
|
t.Fatal("old snapshot writer can overwrite canonical records")
|
|
}
|
|
call("GET", base, nil, "", 409)
|
|
if _, err = db.ExecContext(ctx, `UPDATE materials SET canvas_document=$4,canvas_version=canvas_version+1 WHERE project=$1 AND workspace_id=$2 AND id=$3`, project, workspace, root, legacy); err == nil {
|
|
t.Fatal("database identity barrier allowed an old writer")
|
|
}
|
|
edit := func(n int, versions map[string]int64, changes ...modelChange) response {
|
|
t.Helper()
|
|
key := modelTestID(n)
|
|
input := modelBatch{ProtocolVersion: 2, RequestID: key, Expected: versions, Operations: []modelOperation{{ID: modelTestID(n + 10000), Changes: changes}}}
|
|
return call("POST", base+"/model/operations", input, key, 200)
|
|
}
|
|
titleChange := modelChange{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "data.title", Before: modelJSON("a"), After: modelJSON("renamed")}
|
|
first := edit(1001, map[string]int64{child: 1}, titleChange)
|
|
if first["model"].(map[string]any)["complete"] != false {
|
|
t.Fatal("operation receipt pretends to be a full project snapshot")
|
|
}
|
|
model = read()
|
|
if model.Versions[root] != 2 || model.Versions[child] != 2 || model.Elements[nodeID]["data"].(map[string]any)["text"] != "preserved" {
|
|
t.Fatal("child edit changed unrelated canvas/version/content")
|
|
}
|
|
requestKey := modelTestID(1001)
|
|
repeat := modelBatch{ProtocolVersion: 2, RequestID: requestKey, Expected: map[string]int64{child: 1}, Operations: []modelOperation{{ID: modelTestID(11001), Changes: []modelChange{titleChange}}}}
|
|
call("POST", base+"/model/operations", repeat, requestKey, 200)
|
|
if read().Versions[child] != 2 {
|
|
t.Fatal("exact retry executed twice")
|
|
}
|
|
if call("GET", base+"/model/operations/"+requestKey, nil, "", 200)["status"] != "applied" {
|
|
t.Fatal("lost ACK cannot be queried")
|
|
}
|
|
if call("GET", base+"/model/operations/"+modelTestID(9999), nil, "", 404)["status"] != "unknown" {
|
|
t.Fatal("missing receipt claimed zero writes")
|
|
}
|
|
// Move is a row owner update, retaining ElementId and incarnation.
|
|
geometry := model.Elements[nodeID]["geometry"]
|
|
edit(1002, map[string]int64{root: 2, child: 2}, modelChange{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(child), After: modelJSON(root)}, modelChange{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "geometry", Before: modelJSON(geometry), After: modelJSON(map[string]any{"x": 150, "y": 260, "width": 240, "height": 72, "rotation": 0})})
|
|
model = read()
|
|
if model.Elements[nodeID]["ownerCanvasId"] != root || modelInt(model.Elements[nodeID]["incarnation"]) != 1 {
|
|
t.Fatal("move recreated the element")
|
|
}
|
|
// Future component/envelope bytes survive editing another object and legacy projections.
|
|
opaqueID := modelTestID(3000)
|
|
opaque := modelTestNode(opaqueID, root)
|
|
opaque["componentId"], opaque["dataVersion"], opaque["data"], opaque["futureEnvelope"] = "future.plugin", float64(9), map[string]any{"raw": []any{map[string]any{"keep": true}}}, map[string]any{"extension": "retained"}
|
|
edit(1003, map[string]int64{root: 3}, modelChange{Kind: "element", ID: opaqueID, Before: modelJSON(nil), After: modelJSON(opaque)})
|
|
model = read()
|
|
if !modelEqual(model.Elements[opaqueID], opaque) {
|
|
t.Fatal("future component data changed")
|
|
}
|
|
edit(1004, map[string]int64{root: 4}, modelChange{Kind: "element", ID: nodeID, Before: modelJSON(model.Elements[nodeID]), After: modelJSON(nil)})
|
|
model = read()
|
|
if model.Tombstones[nodeID] != 1 {
|
|
t.Fatal("delete did not persist its lifecycle tombstone")
|
|
}
|
|
restored := modelTestNode(nodeID, root)
|
|
restored["componentId"] = "plain-text"
|
|
restored["incarnation"] = float64(2)
|
|
restored["data"].(map[string]any)["title"] = "restored"
|
|
edit(1005, map[string]int64{root: 5}, modelChange{Kind: "element", ID: nodeID, Before: modelJSON(nil), After: modelJSON(restored)})
|
|
staleKey := modelTestID(1006)
|
|
stale := modelBatch{ProtocolVersion: 2, RequestID: staleKey, Expected: map[string]int64{root: 6}, Operations: []modelOperation{{ID: modelTestID(11006), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 1}, Field: "data.title", Before: modelJSON("restored"), After: modelJSON("stale callback")}}}}}
|
|
if call("POST", base+"/model/operations", stale, staleKey, 409)["status"] != "not-applied" {
|
|
t.Fatal("stale callback did not receive a zero-write receipt")
|
|
}
|
|
if call("GET", base+"/model/operations/"+staleKey, nil, "", 200)["terminal"] != true {
|
|
t.Fatal("terminal rejection was not queryable")
|
|
}
|
|
model = read()
|
|
if model.Versions[root] != 6 || !modelEqual(model.Elements[opaqueID], opaque) || modelInt(model.Elements[nodeID]["incarnation"]) != 2 {
|
|
t.Fatal("stale callback or unrelated update damaged state")
|
|
}
|
|
duplicateKey := modelTestID(1007)
|
|
duplicate := modelBatch{ProtocolVersion: 2, RequestID: duplicateKey, Expected: map[string]int64{root: 6}, Operations: []modelOperation{{ID: modelTestID(11002), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: nodeID, Incarnation: 2}, Field: "data.title", Before: modelJSON("restored"), After: modelJSON("duplicate effect")}}}}}
|
|
if call("POST", base+"/model/operations", duplicate, duplicateKey, 409)["error"] != "operation_already_applied" {
|
|
t.Fatal("logical operation was executed under a new request ID")
|
|
}
|
|
var owner string
|
|
var incarnation int64
|
|
if err = db.QueryRowContext(ctx, `SELECT owner_canvas_id::text,incarnation FROM canvas_model_elements WHERE project=$1 AND element_id=$2 AND NOT deleted`, project, nodeID).Scan(&owner, &incarnation); err != nil || owner != root || incarnation != 2 {
|
|
t.Fatal("canonical row authority disagrees with the API")
|
|
}
|
|
if call("GET", base+"/model", nil, "", 200)["model"].(map[string]any)["complete"] != true {
|
|
t.Fatal("initial read has no explicit coverage")
|
|
}
|
|
// Negotiate the same authenticated canonical read as a streamed transfer.
|
|
streamRequest := httptest.NewRequest("GET", base+"/model", nil)
|
|
streamRequest.Header.Set("Authorization", "Bearer "+token)
|
|
streamRequest.Header.Set("Accept", modelStreamType)
|
|
streamWriter := httptest.NewRecorder()
|
|
mux.ServeHTTP(streamWriter, streamRequest)
|
|
streamed := streamRecords(t, streamWriter)
|
|
if streamWriter.Code != 200 || streamWriter.Header().Get("Content-Type") != modelStreamType || len(streamed) < 2 || streamed[0]["projectId"] != root || streamed[len(streamed)-1]["kind"] != "complete" || !modelEqual(streamed[0]["versions"], read().Versions) {
|
|
t.Fatal("authenticated stream lost canonical snapshot coverage")
|
|
}
|
|
// An object created and removed inside one transaction still has a lifecycle fact.
|
|
ghostID := modelTestID(4000)
|
|
ghost := modelTestNode(ghostID, root)
|
|
edit(1008, map[string]int64{root: 6}, modelChange{Kind: "element", ID: ghostID, Before: modelJSON(nil), After: modelJSON(ghost)}, modelChange{Kind: "element", ID: ghostID, Before: modelJSON(ghost), After: modelJSON(nil)})
|
|
model = read()
|
|
if model.Tombstones[ghostID] != 1 || model.Elements[ghostID] != nil {
|
|
t.Fatal("in-batch create/delete lost its tombstone")
|
|
}
|
|
ghost["incarnation"] = float64(2)
|
|
edit(1009, map[string]int64{root: 7}, modelChange{Kind: "element", ID: ghostID, Before: modelJSON(nil), After: modelJSON(ghost)})
|
|
if modelInt(read().Elements[ghostID]["incarnation"]) != 2 {
|
|
t.Fatal("restore after an in-batch delete did not preserve identity")
|
|
}
|
|
// Session changes cannot send an old account's queued request as a new account.
|
|
request := httptest.NewRequest("GET", base+"/model", nil)
|
|
request.Header.Set("Authorization", "Bearer "+token)
|
|
request.Header.Set("X-Expected-Account", modelTestID(7777))
|
|
writer := httptest.NewRecorder()
|
|
mux.ServeHTTP(writer, request)
|
|
if writer.Code != 409 {
|
|
t.Fatal("expected-account barrier was ignored")
|
|
}
|
|
// A new partition's entry, owning canvas and versions publish atomically.
|
|
newCanvas, newFrame := modelTestID(5000), modelTestID(5001)
|
|
frame := modelTestNode(newFrame, root)
|
|
frame["componentId"] = "frame"
|
|
canvas := modelCanvas{ID: newCanvas, Parent: &modelParent{CanvasID: root, EntryElementID: newFrame}}
|
|
edit(1010, map[string]int64{root: 8, newCanvas: 0}, modelChange{Kind: "canvas", ID: newCanvas, Before: modelJSON(nil), After: modelJSON(canvas)}, modelChange{Kind: "element", ID: newFrame, Before: modelJSON(nil), After: modelJSON(frame)})
|
|
model = read()
|
|
if model.Versions[newCanvas] != 1 || model.Canvases[newCanvas].Parent.EntryElementID != newFrame {
|
|
t.Fatal("partition creation was not atomic")
|
|
}
|
|
edit(1011, map[string]int64{root: 9, newCanvas: 1}, modelChange{Kind: "canvas", ID: newCanvas, Before: modelJSON(canvas), After: modelJSON(nil)}, modelChange{Kind: "element", ID: newFrame, Before: modelJSON(frame), After: modelJSON(nil)})
|
|
model = read()
|
|
if _, exists := model.Canvases[newCanvas]; exists || model.Versions[newCanvas] != 2 {
|
|
t.Fatal("partition archive lost its version fence")
|
|
}
|
|
frame["incarnation"] = float64(2)
|
|
edit(1012, map[string]int64{root: 10, newCanvas: 2}, modelChange{Kind: "element", ID: newFrame, Before: modelJSON(nil), After: modelJSON(frame)}, modelChange{Kind: "canvas", ID: newCanvas, Before: modelJSON(nil), After: modelJSON(canvas)})
|
|
model = read()
|
|
if model.Versions[newCanvas] != 3 || modelInt(model.Elements[newFrame]["incarnation"]) != 2 {
|
|
t.Fatal("partition restore reused a stale lifecycle or version")
|
|
}
|
|
|
|
// A cross-scale entry move writes ownership, child binding and presentation units together.
|
|
innerCanvas, innerFrame, memberID := modelTestID(5100), modelTestID(5101), modelTestID(5102)
|
|
container := modelTestNode(innerFrame, root)
|
|
container["componentId"] = "frame"
|
|
originalPresentation := response{"contentScale": .75, "future": response{"keep": "metadata"}}
|
|
container["data"].(map[string]any)["presentation"] = originalPresentation
|
|
member := modelTestNode(memberID, innerCanvas)
|
|
member["data"].(map[string]any)["fontSize"] = float64(17)
|
|
inner := modelCanvas{ID: innerCanvas, Parent: &modelParent{CanvasID: root, EntryElementID: innerFrame}}
|
|
absent := false
|
|
edit(1013, map[string]int64{root: model.Versions[root], newCanvas: model.Versions[newCanvas], innerCanvas: 0},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: newFrame, Incarnation: 2}, Field: "data.presentation", Before: modelJSON(nil), BeforePresent: &absent, After: modelJSON(response{"contentScale": 2})},
|
|
modelChange{Kind: "element", ID: innerFrame, Before: modelJSON(nil), After: modelJSON(container)},
|
|
modelChange{Kind: "canvas", ID: innerCanvas, Before: modelJSON(nil), After: modelJSON(inner)},
|
|
modelChange{Kind: "element", ID: memberID, Before: modelJSON(nil), After: modelJSON(member)})
|
|
model = read()
|
|
oldGeometry := model.Elements[innerFrame]["geometry"]
|
|
containerGeometry := oldGeometry.(map[string]any)
|
|
normalizedGeometry := response{"x": (containerGeometry["x"].(float64) - 24) / 2, "y": (containerGeometry["y"].(float64) - 36) / 2, "width": containerGeometry["width"].(float64) / 2, "height": containerGeometry["height"].(float64) / 2, "rotation": containerGeometry["rotation"]}
|
|
normalizedPresentation := response{"contentScale": .75, "unitScale": .5, "future": response{"keep": "metadata"}}
|
|
movedInner := inner
|
|
movedInner.Parent = &modelParent{CanvasID: newCanvas, EntryElementID: innerFrame}
|
|
edit(1014, map[string]int64{root: model.Versions[root], newCanvas: model.Versions[newCanvas], innerCanvas: model.Versions[innerCanvas]},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(root), After: modelJSON(newCanvas)},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "geometry", Before: modelJSON(oldGeometry), After: modelJSON(normalizedGeometry)},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "data.presentation", Before: modelJSON(originalPresentation), After: modelJSON(normalizedPresentation)},
|
|
modelChange{Kind: "canvas", ID: innerCanvas, Before: modelJSON(inner), After: modelJSON(movedInner)})
|
|
model = read()
|
|
if modelString(model.Elements[innerFrame]["ownerCanvasId"]) != newCanvas || model.Canvases[innerCanvas].Parent.CanvasID != newCanvas || !modelEqual(model.Elements[innerFrame]["data"].(map[string]any)["presentation"], normalizedPresentation) || !modelEqual(model.Elements[memberID], member) {
|
|
t.Fatal("scaled container move changed its member or lost the atomic unit/ownership boundary")
|
|
}
|
|
if call("GET", base+"/model/operations/"+modelTestID(1014), nil, "", 200)["status"] != "applied" {
|
|
t.Fatal("scaled move receipt was not queryable by its original identity")
|
|
}
|
|
edit(1015, map[string]int64{root: model.Versions[root], newCanvas: model.Versions[newCanvas], innerCanvas: model.Versions[innerCanvas]},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "ownerCanvasId", Before: modelJSON(newCanvas), After: modelJSON(root)},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "geometry", Before: modelJSON(normalizedGeometry), After: modelJSON(oldGeometry)},
|
|
modelChange{Kind: "field", Target: modelTarget{ID: innerFrame, Incarnation: 1}, Field: "data.presentation", Before: modelJSON(normalizedPresentation), After: modelJSON(originalPresentation)},
|
|
modelChange{Kind: "canvas", ID: innerCanvas, Before: modelJSON(movedInner), After: modelJSON(inner)})
|
|
model = read()
|
|
if _, exists := model.Elements[innerFrame]["data"].(map[string]any)["presentation"].(map[string]any)["unitScale"]; exists || !modelEqual(model.Elements[memberID], member) || model.Canvases[innerCanvas].Parent.CanvasID != root {
|
|
t.Fatal("scaled move inverse did not restore absent unit metadata and the original child binding")
|
|
}
|
|
// Several logical edits share one atomic request while retaining every deduplication identity.
|
|
batchKey, firstLogical, secondLogical := modelTestID(1016), modelTestID(22001), modelTestID(22002)
|
|
batchVersion := model.Versions[innerCanvas]
|
|
batch := modelBatch{ProtocolVersion: 2, RequestID: batchKey, Expected: map[string]int64{innerCanvas: batchVersion}, Operations: []modelOperation{
|
|
{ID: firstLogical, Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON(memberID), After: modelJSON("intermediate")}}},
|
|
{ID: secondLogical, Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("intermediate"), After: modelJSON("batched")}}},
|
|
}}
|
|
batched := call("POST", base+"/model/operations", batch, batchKey, 200)
|
|
if !modelEqual(batched["operation_ids"], []string{firstLogical, secondLogical}) {
|
|
t.Fatal("batch receipt did not cover every original logical ID")
|
|
}
|
|
model = read()
|
|
if model.Versions[innerCanvas] != batchVersion+1 || modelString(model.Elements[memberID]["data"].(map[string]any)["title"]) != "batched" {
|
|
t.Fatal("batch lost ordered conditions or advanced the canvas version more than once")
|
|
}
|
|
if !modelEqual(call("GET", base+"/model/operations/"+batchKey, nil, "", 200), batched) || !modelEqual(call("POST", base+"/model/operations", batch, batchKey, 200), batched) {
|
|
t.Fatal("batch query/retry did not return its original receipt")
|
|
}
|
|
batch.RequestID = modelTestID(1017)
|
|
batch.Expected[innerCanvas] = model.Versions[innerCanvas]
|
|
batch.Operations = batch.Operations[:1]
|
|
if call("POST", base+"/model/operations", batch, batch.RequestID, 409)["error"] != "operation_already_applied" {
|
|
t.Fatal("a covered logical ID was executable under a new request key")
|
|
}
|
|
// A later failed condition cannot publish the earlier edit or consume its logical identity.
|
|
failedKey := modelTestID(1018)
|
|
batch.RequestID = failedKey
|
|
batch.Operations = []modelOperation{
|
|
{ID: modelTestID(22003), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("batched"), After: modelJSON("must roll back")}}},
|
|
{ID: modelTestID(22004), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("wrong before"), After: modelJSON("invalid")}}},
|
|
}
|
|
if call("POST", base+"/model/operations", batch, failedKey, 409)["status"] != "not-applied" {
|
|
t.Fatal("failed batch did not produce a zero-write terminal receipt")
|
|
}
|
|
model = read()
|
|
if model.Versions[innerCanvas] != batchVersion+1 || modelString(model.Elements[memberID]["data"].(map[string]any)["title"]) != "batched" {
|
|
t.Fatal("a failed batch leaked its successful prefix")
|
|
}
|
|
var consumed int
|
|
if err = db.QueryRowContext(ctx, `SELECT count(*) FROM canvas_model_operations WHERE project=$1 AND operation_id=$2`, project, modelTestID(22003)).Scan(&consumed); err != nil || consumed != 0 {
|
|
t.Fatal("a rejected atomic prefix consumed a logical operation ID")
|
|
}
|
|
|
|
// A compacted wire projection retains prefix IDs with conditional no-ops, including in a child scope.
|
|
projectedKey, guardLogical, effectLogical := modelTestID(1019), modelTestID(22005), modelTestID(22006)
|
|
projectedGhost := modelTestID(5200)
|
|
finalGhost := modelTestNode(projectedGhost, innerCanvas)
|
|
finalGhost["data"].(map[string]any)["text"] = "composed final value"
|
|
parentVersion := model.Versions[root]
|
|
projection := modelBatch{ProtocolVersion: 2, RequestID: projectedKey, Expected: map[string]int64{innerCanvas: model.Versions[innerCanvas]}, Operations: []modelOperation{
|
|
{ID: guardLogical, Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("batched"), After: modelJSON("batched")}}},
|
|
{ID: effectLogical, Changes: []modelChange{
|
|
{Kind: "field", Target: modelTarget{ID: memberID, Incarnation: 1}, Field: "data.title", Before: modelJSON("batched"), After: modelJSON("projected final")},
|
|
{Kind: "element", ID: projectedGhost, Before: modelJSON(nil), After: modelJSON(finalGhost)},
|
|
{Kind: "element", ID: projectedGhost, Before: modelJSON(finalGhost), After: modelJSON(nil)},
|
|
}},
|
|
}}
|
|
projectedReceipt := call("POST", base+"/model/operations", projection, projectedKey, 200)
|
|
model = read()
|
|
if !modelEqual(projectedReceipt["operation_ids"], []string{guardLogical, effectLogical}) || model.Versions[innerCanvas] != batchVersion+2 || model.Versions[root] != parentVersion {
|
|
t.Fatal("projected prefix lost its logical coverage or widened the child writer scope")
|
|
}
|
|
if modelString(model.Elements[memberID]["data"].(map[string]any)["title"]) != "projected final" || model.Tombstones[projectedGhost] != 1 || !modelEqual(model.DeadRecords[projectedGhost], finalGhost) {
|
|
t.Fatal("projected effect lost final data, tombstone or archived lifecycle record")
|
|
}
|
|
if !modelEqual(call("GET", base+"/model/operations/"+projectedKey, nil, "", 200), projectedReceipt) {
|
|
t.Fatal("compacted projection receipt was not recoverable by its original key")
|
|
}
|
|
|
|
// A locally canceled incarnation was never sent; undo may first publish incarnation 2.
|
|
locallyElidedID := modelTestID(5201)
|
|
locallyRestored := modelTestNode(locallyElidedID, innerCanvas)
|
|
locallyRestored["incarnation"] = float64(2)
|
|
edit(1020, map[string]int64{innerCanvas: model.Versions[innerCanvas]}, modelChange{Kind: "element", ID: locallyElidedID, Before: modelJSON(nil), After: modelJSON(locallyRestored)})
|
|
model = read()
|
|
if modelInt(model.Elements[locallyElidedID]["incarnation"]) != 2 || model.Tombstones[locallyElidedID] != 0 {
|
|
t.Fatal("local elision undo reused a canceled life or invented an ACK tombstone")
|
|
}
|
|
staleElisionKey := modelTestID(1021)
|
|
staleElision := modelBatch{ProtocolVersion: 2, RequestID: staleElisionKey, Expected: map[string]int64{innerCanvas: model.Versions[innerCanvas]}, Operations: []modelOperation{{ID: modelTestID(22007), Changes: []modelChange{{Kind: "field", Target: modelTarget{ID: locallyElidedID, Incarnation: 1}, Field: "data.title", Before: modelJSON(locallyElidedID), After: modelJSON("stale local callback")}}}}}
|
|
if call("POST", base+"/model/operations", staleElision, staleElisionKey, 409)["status"] != "not-applied" || !modelEqual(read().Elements[locallyElidedID], locallyRestored) {
|
|
t.Fatal("a callback from the locally canceled incarnation changed its restored successor")
|
|
}
|
|
|
|
}
|