Files
Bedrock/internal/platform/canvas_ai_real_test.go
T

179 lines
8.5 KiB
Go

// 可选真实模型回归:只有明确配置专用 worker socket 与隔离数据库才运行,会调用实际文本和图片生成。
package platform
import (
"bytes"
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"image"
"image/png"
"net/http"
"net/http/httptest"
"os"
"strconv"
"strings"
"testing"
"gitea.entroia.com/Zayden-Jung/Bedrock/internal/codex"
)
// Opt in only on the confirmed remote runner with its dedicated CLI worker.
// Normal CI never invokes a paid/real model as a side effect of unit tests.
// TestCanvasAIRealWorker 选择配对文本/图片模型,走准入、认领、生成写回和授权下载,最后完整解码生成图片。
// 环境变量只是测试开关,执行前仍须确认专用远程 runner 和真实模型调用授权。
func TestCanvasAIRealWorker(t *testing.T) {
socket, dsn := os.Getenv("FOUNDRY_REAL_CODEX_SOCKET"), os.Getenv("PLATFORM_TEST_DATABASE_URL")
if socket == "" || dsn == "" {
t.Skip("requires explicitly configured real worker and isolated database")
}
ctx := context.Background()
client := codex.NewCanvasClient(socket)
models, err := client.Models(ctx)
if err != nil {
t.Fatal(err)
}
// 先选显式已验证图片输出条目,再按去掉 Image 后缀的标签寻找对应文本模型,缺能力直接失败。
var imageModel, textModel codex.CanvasModel
for _, model := range models {
if model.Available && canvasModelSupports(model, "image") {
imageModel = model
break
}
}
if imageModel.ID == "" {
t.Fatal("real worker has no verified image model")
}
label := strings.TrimSuffix(imageModel.Label, " · Image")
for _, model := range models {
if model.Available && model.Label == label && canvasModelSupports(model, "text") {
textModel = model
break
}
}
if textModel.ID == "" {
t.Fatal("matching real text model not available")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
defer db.Close()
var random [32]byte
_, _ = rand.Read(random[:])
project := "real-canvas-" + hex.EncodeToString(random[:8])
token := base64.RawURLEncoding.EncodeToString(random[:])
hash := sha256.Sum256([]byte(token))
var account, workspace, board 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() {
_, _ = db.ExecContext(ctx, `DELETE FROM canvas_ai_runs WHERE project=$1`, project)
_, _ = db.ExecContext(ctx, `DELETE FROM canvas_asset_bindings WHERE project=$1`, project)
_, _ = db.ExecContext(ctx, `DELETE FROM canvas_assets WHERE project=$1`, project)
_, _ = db.ExecContext(ctx, `DELETE FROM workspaces WHERE project=$1`, project)
_, _ = db.ExecContext(ctx, `DELETE FROM project_accounts WHERE project=$1`, project)
}()
if _, err = db.ExecContext(ctx, `INSERT INTO project_sessions 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,'Real worker fixture',$2) RETURNING id::text`, project, account).Scan(&workspace); err != nil {
t.Fatal(err)
}
if _, err = db.ExecContext(ctx, `INSERT INTO workspace_members VALUES($1,$2,$3,'admin',now())`, 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','Real worker fixture',$3,$4) RETURNING id::text`, project, workspace, account, json.RawMessage(canvasFixture)).Scan(&board); err != nil {
t.Fatal(err)
}
s := &service{db: db, origin: "https://api.example.com", canvasAI: client}
callbacks := map[string]string{project: "https://app.example.com/auth/callback"}
mux := http.NewServeMux()
prefix := "/projects/{project}/workspaces/{workspace}/materials/{material}/canvas"
base := "/projects/" + project + "/workspaces/" + workspace + "/materials/" + board + "/canvas"
mux.HandleFunc(prefix, s.protected(callbacks, s.canvas))
mux.HandleFunc("POST "+prefix+"/ai/runs", s.protected(callbacks, s.createCanvasAIRun))
mux.HandleFunc(prefix+"/ai/runs/{run}", s.protected(callbacks, s.getCanvasAIRun))
mux.HandleFunc("/projects/{project}/workspaces/{workspace}/assets/{asset}", s.protected(callbacks, s.getAsset))
call := func(method, path string, body any, status int, version int64, key string) response {
t.Helper()
raw, _ := json.Marshal(body)
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 version > 0 {
request.Header.Set("If-Match", `"`+strconv.FormatInt(version, 10)+`"`)
}
if key != "" {
request.Header.Set("Idempotency-Key", key)
}
recorder := httptest.NewRecorder()
mux.ServeHTTP(recorder, request)
if recorder.Code != status {
t.Fatalf("%s got %d %s", method, recorder.Code, recorder.Body.String())
}
result := response{}
if err := json.Unmarshal(recorder.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
return result
}
// 手动认领指定 run,避免后台轮询干扰;数据库必须隔离,否则最早队列任务可能不是本用例。
execute := func(id string) {
t.Helper()
run, err := s.claimCanvasRun(ctx)
if err != nil || run == nil || run.ID != id {
t.Fatalf("real worker claim: %v", err)
}
s.executeCanvasRun(ctx, *run)
result := call("GET", base+"/ai/runs/"+id, nil, 200, 0, "")
if result["status"] != "succeeded" {
encoded, _ := json.Marshal(result["steps"])
t.Fatalf("real worker run %s: %s", result["status"], encoded)
}
}
// 文本用例只检查标记包含及原几何保留,不把模型自然语言差异当作精确输出契约。
textRun := call("POST", base+"/ai/runs", response{"node_id": "a", "model_id": textModel.ID, "prompt": "Return exactly the text CANVAS_V2_OK", "parameters": response{}, "propagate": false}, 202, 1, "20000000-0000-4000-8000-000000000001")
execute(textRun["run_id"].(string))
textSaved := call("GET", base, nil, 200, 0, "")
doc := textSaved["document"].(map[string]any)
textNode := doc["nodes"].([]any)[0].(map[string]any)
if !strings.Contains(textNode["data"].(map[string]any)["text"].(string), "CANVAS_V2_OK") || textNode["width"] != float64(320) {
t.Fatal("real text result or geometry invalid")
}
var input bytes.Buffer
if err := png.Encode(&input, image.NewRGBA(image.Rect(0, 0, 32, 32))); err != nil {
t.Fatal(err)
}
doc["nodes"] = append(doc["nodes"].([]any), response{"id": "real-image", "type": "plainImage", "position": response{"x": 40, "y": 50}, "width": 240, "height": 160, "data": response{"kind": "plain-image", "title": "Real image", "text": "", "src": "data:image/png;base64," + base64.StdEncoding.EncodeToString(input.Bytes())}})
call("PATCH", base, response{"document": doc}, 200, 3, "")
// 图片结果必须成为托管资产,保留节点显示尺寸;实际原图尺寸/格式由下载后的完整解码验证。
imageRun := call("POST", base+"/ai/runs", response{"node_id": "real-image", "model_id": imageModel.ID, "prompt": "Generate one image: a solid blue circle centered on a white square background, no text.", "parameters": response{}, "propagate": false}, 202, 4, "20000000-0000-4000-8000-000000000002")
execute(imageRun["run_id"].(string))
saved := call("GET", base, nil, 200, 0, "")
node := saved["document"].(map[string]any)["nodes"].([]any)[3].(map[string]any)
data := node["data"].(map[string]any)
id, ok := data["assetId"].(string)
if !ok || !uuidSlugPattern.MatchString(id) || node["width"] != float64(240) || node["height"] != float64(160) {
t.Fatal("real image not applied as managed asset")
}
request := httptest.NewRequest("GET", data["src"].(string), nil)
request.Header.Set("Authorization", "Bearer "+token)
recorder := httptest.NewRecorder()
mux.ServeHTTP(recorder, request)
if recorder.Code != 200 {
t.Fatal("real asset unreadable")
}
mime, width, height, err := inspectAsset(recorder.Body.Bytes())
if err != nil || mime != recorder.Header().Get("Content-Type") {
t.Fatal("real generated bytes failed full image decode")
}
digest := sha256.Sum256(recorder.Body.Bytes())
t.Logf("real text model=%s run=%s; image model=%s run=%s asset=%s mime=%s dimensions=%dx%d bytes=%d sha256=%s", textModel.ID, textRun["run_id"], imageModel.ID, imageRun["run_id"], id, mime, width, height, recorder.Body.Len(), hex.EncodeToString(digest[:]))
}