Files
Bedrock/internal/platform/canvas_model_stream_test.go
T
codex-bot e38254821a
Foundry Go checks / check (push) Failing after 10m37s
Foundry Go checks / check (pull_request) Failing after 10m45s
Stream negotiated canonical model reads with snapshot framing
2026-11-09 02:01:46 +08:00

93 lines
2.9 KiB
Go

package platform
import (
"bufio"
"context"
"encoding/json"
"fmt"
"net/http/httptest"
"testing"
)
func streamRecords(t *testing.T, writer *httptest.ResponseRecorder) []response {
t.Helper()
var records []response
scanner := bufio.NewScanner(writer.Body)
for scanner.Scan() {
var record response
if err := json.Unmarshal(scanner.Bytes(), &record); err != nil {
t.Fatal(err)
}
records = append(records, record)
}
if err := scanner.Err(); err != nil {
t.Fatal(err)
}
return records
}
func TestCanonicalModelStreamFramesAndSnapshot(t *testing.T) {
model := modelTestDocument()
for i := 0; i < 129; i++ {
id := fmt.Sprintf("extra-%03d", i)
model.Elements[id] = modelTestNode(id, modelRootID)
}
model.Tombstones["deleted"] = 2
model.TombstoneOwners["deleted"] = modelRootID
writer := httptest.NewRecorder()
writeCanvasModelStream(context.Background(), writer, model)
if writer.Code != 200 || writer.Header().Get("Content-Type") != modelStreamType || !writer.Flushed {
t.Fatal("stream was not negotiated/flushed", writer.Code, writer.Header())
}
records := streamRecords(t, writer)
if len(records) != 5 || records[0]["kind"] != "header" || records[4]["kind"] != "complete" {
t.Fatal("missing stream framing", len(records))
}
token := modelString(records[0]["snapshotToken"])
if !uuidSlugPattern.MatchString(token) || records[0]["projectId"] != modelRootID || !modelEqual(records[0]["versions"], model.Versions) || !modelEqual(records[0]["tombstones"], model.Tombstones) {
t.Fatal("stream header lost snapshot identity")
}
seen := map[string]bool{}
for i, record := range records {
if record["sequence"] != float64(i) || record["snapshotToken"] != token || record["streamVersion"] != float64(1) {
t.Fatal("mixed or unordered snapshot")
}
if record["kind"] == "elements" {
items := record["elements"].([]any)
if len(items) == 0 || len(items) > 64 {
t.Fatal("unbounded record batch")
}
for _, item := range items {
element := item.(map[string]any)
id := modelString(element["id"])
if seen[id] || !modelEqual(element, model.Elements[id]) {
t.Fatal("duplicated or corrupted stream element")
}
seen[id] = true
}
}
}
if len(seen) != len(model.Elements) || records[4]["elementCount"] != float64(len(seen)) {
t.Fatal("terminal coverage mismatch")
}
}
type cancelStreamWriter struct {
*httptest.ResponseRecorder
cancel context.CancelFunc
}
func (writer cancelStreamWriter) Flush() {
writer.ResponseRecorder.Flush()
writer.cancel()
}
func TestCanonicalModelStreamCancellationNeverClaimsCompletion(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
writer := httptest.NewRecorder()
writeCanvasModelStream(ctx, cancelStreamWriter{writer, cancel}, modelTestDocument())
records := streamRecords(t, writer)
if len(records) != 1 || records[0]["kind"] != "header" {
t.Fatal("cancelled stream wrote a tail", len(records))
}
}