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/foundry-core/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. 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) } 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 } 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[:])) }