droboticflow/internal/api/server_test.go
eust-w 43326d6a5e feat(platform): land workflow, data tooling, and docs updates
Include the accumulated workflow scheduling, run history, subtree rerun, operator UI, deployment, data asset, object storage, database browser, and documentation changes currently in the worktree.
2026-04-24 12:29:46 +08:00

4364 lines
158 KiB
Go

package api
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"mime/multipart"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"sort"
"strings"
"testing"
"droboticflow/internal/domain"
"droboticflow/internal/store"
bosapi "github.com/baidubce/bce-sdk-go/services/bos/api"
)
func TestListStorageObjectsFromConnectionNormalizesDirectoryPrefixes(t *testing.T) {
tests := []struct {
name string
prefix string
expected string
}{
{name: "empty", prefix: "", expected: ""},
{name: "trimmed root child", prefix: "algo", expected: "algo/"},
{name: "preserve nested directory", prefix: "algo/X-platform-test", expected: "algo/X-platform-test/"},
{name: "trim slashes", prefix: "/algo/X-platform-test//", expected: "algo/X-platform-test/"},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
requestPrefix := storageObjectRequestPrefix(test.prefix)
if requestPrefix != test.expected {
t.Fatalf("request prefix = %q, want %q", requestPrefix, test.expected)
}
})
}
}
func TestAppendStorageObjectItemsSkipsCurrentPrefixAndDedupesPages(t *testing.T) {
collected := make(map[string]struct{})
appendStorageObjectItems(
collected,
&bosapi.ListObjectsResult{
CommonPrefixes: []bosapi.PrefixType{
{Prefix: "algo/"},
{Prefix: "algo/X-platform-test/"},
},
Contents: []bosapi.ObjectSummaryType{
{Key: "algo/"},
{Key: "algo/manifest.json"},
},
},
"algo",
"algo/",
)
appendStorageObjectItems(
collected,
&bosapi.ListObjectsResult{
CommonPrefixes: []bosapi.PrefixType{
{Prefix: "algo/X-platform-test/"},
{Prefix: "algo/raw/"},
},
Contents: []bosapi.ObjectSummaryType{
{Key: "algo/manifest.json"},
{Key: "algo/video.mp4"},
},
},
"algo",
"algo/",
)
items := make([]string, 0, len(collected))
for item := range collected {
items = append(items, item)
}
sort.Strings(items)
expected := []string{
"algo/X-platform-test/",
"algo/manifest.json",
"algo/raw/",
"algo/video.mp4",
}
if strings.Join(items, "|") != strings.Join(expected, "|") {
t.Fatalf("items = %#v, want %#v", items, expected)
}
}
func TestWorkerAPIHealthIsProxiedThroughAPI(t *testing.T) {
worker := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if request.URL.Path != "/worker-api/health" {
t.Fatalf("unexpected upstream path: %s", request.URL.Path)
}
writer.Header().Set("Content-Type", "application/json")
_, _ = writer.Write([]byte(`{"status":"ok","service":"droboticflow-worker"}`))
}))
defer worker.Close()
originalResolver := workerAPIBaseURLResolver
workerAPIBaseURLResolver = func() string { return worker.URL }
t.Cleanup(func() {
workerAPIBaseURLResolver = originalResolver
})
handler := NewHandler(store.NewMemoryStore(), nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/worker-api/health", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("expected 200, got %d body=%s", recorder.Code, recorder.Body.String())
}
if got := strings.TrimSpace(recorder.Body.String()); got != `{"status":"ok","service":"droboticflow-worker"}` {
t.Fatalf("unexpected worker health payload: %s", got)
}
}
func TestWorkerAPIProcessOnceIsProxiedThroughAPI(t *testing.T) {
worker := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if request.Method != http.MethodPost {
t.Fatalf("unexpected upstream method: %s", request.Method)
}
if request.URL.Path != "/worker-api/process-once" {
t.Fatalf("unexpected upstream path: %s", request.URL.Path)
}
writer.Header().Set("Content-Type", "application/json")
writer.WriteHeader(http.StatusOK)
_, _ = writer.Write([]byte(`{"run":{"id":"run-1","status":"running"}}`))
}))
defer worker.Close()
originalResolver := workerAPIBaseURLResolver
workerAPIBaseURLResolver = func() string { return worker.URL }
t.Cleanup(func() {
workerAPIBaseURLResolver = originalResolver
})
handler := NewHandler(store.NewMemoryStore(), nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/worker-api/process-once", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("expected 200, got %d body=%s", recorder.Code, recorder.Body.String())
}
if got := strings.TrimSpace(recorder.Body.String()); got != `{"run":{"id":"run-1","status":"running"}}` {
t.Fatalf("unexpected worker process-once payload: %s", got)
}
}
func TestAPIHandlerSupportsDashboardCRUDAndRunQueueing(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
storageRoot := t.TempDir()
for _, bucket := range []string{"incoming", "processed"} {
if err := os.Mkdir(filepath.Join(storageRoot, bucket), 0o755); err != nil {
t.Fatalf("create bucket %s: %v", bucket, err)
}
}
settings, err := dataStore.GetSettings(ctx)
if err != nil {
t.Fatalf("get settings: %v", err)
}
settings.K8s.Kubeconfig = "apiVersion: v1"
if err := dataStore.UpsertSettings(ctx, *settings); err != nil {
t.Fatalf("update settings: %v", err)
}
if _, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "Dashboard 项目",
Description: "用于 dashboard 验证",
}); err != nil {
t.Fatalf("create dashboard project: %v", err)
}
handler := NewHandler(dataStore, nil)
dashboardRecorder := httptest.NewRecorder()
handler.ServeHTTP(dashboardRecorder, httptest.NewRequest(http.MethodGet, "/api/dashboard", nil))
if dashboardRecorder.Code != http.StatusOK {
t.Fatalf("dashboard status: %d", dashboardRecorder.Code)
}
var dashboardBody map[string]any
if err := json.Unmarshal(dashboardRecorder.Body.Bytes(), &dashboardBody); err != nil {
t.Fatalf("decode dashboard: %v", err)
}
projects := dashboardBody["projects"].(map[string]any)
if projects["active"].(float64) <= 0 {
t.Fatalf("expected active projects")
}
projectPayload := []byte(`{"name":"API 项目","description":"通过 API 创建"}`)
projectRecorder := httptest.NewRecorder()
handler.ServeHTTP(projectRecorder, httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader(projectPayload)))
if projectRecorder.Code != http.StatusCreated {
t.Fatalf("project create status: %d body=%s", projectRecorder.Code, projectRecorder.Body.String())
}
var createdProject map[string]any
if err := json.Unmarshal(projectRecorder.Body.Bytes(), &createdProject); err != nil {
t.Fatalf("decode created project: %v", err)
}
projectID := createdProject["id"].(string)
if projectID == "" {
t.Fatalf("expected project id")
}
workflowPayload := []byte(`{"name":"API 工作流","description":"workflow","nodes":[{"id":"node-source","type":"operator","data":{"label":"真实数据源","category":"IO","description":"source","inputs":[],"outputs":[{"id":"out-1","name":"file","type":"file"}],"hyperparams":[{"key":"SOURCE_TEXT","value":"api-test"}]},"position":{"x":0,"y":0}}],"edges":[]}`)
workflowRecorder := httptest.NewRecorder()
handler.ServeHTTP(workflowRecorder, httptest.NewRequest(http.MethodPost, "/api/projects/"+projectID+"/workflows", bytes.NewReader(workflowPayload)))
if workflowRecorder.Code != http.StatusCreated {
t.Fatalf("workflow create status: %d body=%s", workflowRecorder.Code, workflowRecorder.Body.String())
}
var createdWorkflow map[string]any
if err := json.Unmarshal(workflowRecorder.Body.Bytes(), &createdWorkflow); err != nil {
t.Fatalf("decode workflow: %v", err)
}
if createdWorkflow["type"].(string) != "batch" {
t.Fatalf("expected workflow type to default to batch, got %v", createdWorkflow["type"])
}
projectsRecorder := httptest.NewRecorder()
handler.ServeHTTP(projectsRecorder, httptest.NewRequest(http.MethodGet, "/api/projects", nil))
if projectsRecorder.Code != http.StatusOK {
t.Fatalf("projects list status: %d body=%s", projectsRecorder.Code, projectsRecorder.Body.String())
}
var projectsBody struct {
Items []map[string]any `json:"items"`
}
if err := json.Unmarshal(projectsRecorder.Body.Bytes(), &projectsBody); err != nil {
t.Fatalf("decode projects list: %v", err)
}
var countedProject map[string]any
for _, item := range projectsBody.Items {
if item["id"] == projectID {
countedProject = item
break
}
}
if countedProject == nil {
t.Fatalf("expected created project in projects list")
}
if countedProject["workflowCount"].(float64) != 1 {
t.Fatalf("expected workflowCount=1 in projects list, got %v", countedProject["workflowCount"])
}
projectGetRecorder := httptest.NewRecorder()
handler.ServeHTTP(projectGetRecorder, httptest.NewRequest(http.MethodGet, "/api/projects/"+projectID, nil))
if projectGetRecorder.Code != http.StatusOK {
t.Fatalf("project get status: %d body=%s", projectGetRecorder.Code, projectGetRecorder.Body.String())
}
var projectGetBody map[string]any
if err := json.Unmarshal(projectGetRecorder.Body.Bytes(), &projectGetBody); err != nil {
t.Fatalf("decode project get: %v", err)
}
if projectGetBody["workflowCount"].(float64) != 1 {
t.Fatalf("expected workflowCount=1 in project get, got %v", projectGetBody["workflowCount"])
}
runPayload := []byte(`{"trigger":"manual"}`)
runRecorder := httptest.NewRecorder()
handler.ServeHTTP(runRecorder, httptest.NewRequest(http.MethodPost, "/api/workflows/"+createdWorkflow["id"].(string)+"/run", bytes.NewReader(runPayload)))
if runRecorder.Code != http.StatusAccepted {
t.Fatalf("run create status: %d body=%s", runRecorder.Code, runRecorder.Body.String())
}
var queuedRun map[string]any
if err := json.Unmarshal(runRecorder.Body.Bytes(), &queuedRun); err != nil {
t.Fatalf("decode queued run: %v", err)
}
if queuedRun["status"].(string) != "queued" {
t.Fatalf("expected queued status, got %v", queuedRun["status"])
}
userPayload := []byte(`{"name":"API User","email":"api-user@example.com","role":"admin"}`)
userRecorder := httptest.NewRecorder()
handler.ServeHTTP(userRecorder, httptest.NewRequest(http.MethodPost, "/api/users", bytes.NewReader(userPayload)))
if userRecorder.Code != http.StatusCreated {
t.Fatalf("user create status: %d body=%s", userRecorder.Code, userRecorder.Body.String())
}
runsRecorder := httptest.NewRecorder()
handler.ServeHTTP(runsRecorder, httptest.NewRequest(http.MethodGet, "/api/runs", nil))
if runsRecorder.Code != http.StatusOK {
t.Fatalf("runs list status: %d", runsRecorder.Code)
}
var runsBody struct {
Items []map[string]any `json:"items"`
}
if err := json.Unmarshal(runsRecorder.Body.Bytes(), &runsBody); err != nil {
t.Fatalf("decode runs: %v", err)
}
foundRun := false
for _, item := range runsBody.Items {
if item["id"] == queuedRun["id"] {
foundRun = true
break
}
}
if !foundRun {
t.Fatalf("expected queued run in listing")
}
bucketsRecorder := httptest.NewRecorder()
handler.ServeHTTP(bucketsRecorder, httptest.NewRequest(http.MethodGet, "/api/storage/buckets?sourcePath="+storageRoot, nil))
if bucketsRecorder.Code != http.StatusOK {
t.Fatalf("buckets status: %d", bucketsRecorder.Code)
}
var bucketsBody struct {
Items []string `json:"items"`
}
if err := json.Unmarshal(bucketsRecorder.Body.Bytes(), &bucketsBody); err != nil {
t.Fatalf("decode buckets: %v", err)
}
if len(bucketsBody.Items) == 0 {
t.Fatalf("expected storage buckets")
}
objectsRecorder := httptest.NewRecorder()
handler.ServeHTTP(
objectsRecorder,
httptest.NewRequest(http.MethodGet, "/api/storage/objects?sourcePath="+storageRoot+"&bucket=incoming&prefix=", nil),
)
if objectsRecorder.Code != http.StatusOK {
t.Fatalf("objects status: %d", objectsRecorder.Code)
}
missingSourcePathRecorder := httptest.NewRecorder()
handler.ServeHTTP(missingSourcePathRecorder, httptest.NewRequest(http.MethodGet, "/api/storage/buckets", nil))
if missingSourcePathRecorder.Code != http.StatusBadRequest {
t.Fatalf("missing sourcePath status: %d", missingSourcePathRecorder.Code)
}
aiRecorder := httptest.NewRecorder()
handler.ServeHTTP(aiRecorder, httptest.NewRequest(http.MethodGet, "/api/ai/status", nil))
if aiRecorder.Code != http.StatusOK {
t.Fatalf("ai status: %d", aiRecorder.Code)
}
}
func TestOperatorsListEnsuresMongoWriteBuiltin(t *testing.T) {
handler := NewHandler(store.NewMemoryStore(), nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/operators", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("operators list status: %d body=%s", recorder.Code, recorder.Body.String())
}
var response struct {
Items []domain.OperatorRecord `json:"items"`
}
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode operators list: %v", err)
}
var mongoWrite *domain.OperatorRecord
for index := range response.Items {
item := response.Items[index]
if item.Name == "MongoDB 写入" {
mongoWrite = &item
break
}
}
if mongoWrite == nil {
t.Fatalf("expected MongoDB 写入 builtin operator to be present")
}
if mongoWrite.Category != "DATA" {
t.Fatalf("expected MongoDB 写入 category DATA, got %q", mongoWrite.Category)
}
if len(mongoWrite.Inputs) == 0 || len(mongoWrite.Outputs) == 0 {
t.Fatalf("expected MongoDB 写入 ports to be defined")
}
foundTarget := false
for _, param := range mongoWrite.Hyperparams {
if param.Key == "MONGO_TARGET" && param.Value == "business" {
foundTarget = true
break
}
}
if !foundTarget {
t.Fatalf("expected MongoDB 写入 to default MONGO_TARGET=business")
}
}
func TestOperatorsListEnsuresRegressionBuiltinCatalog(t *testing.T) {
handler := NewHandler(store.NewMemoryStore(), nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/operators", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("operators list status: %d body=%s", recorder.Code, recorder.Body.String())
}
var response struct {
Items []domain.OperatorRecord `json:"items"`
}
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode operators list: %v", err)
}
byName := make(map[string]domain.OperatorRecord, len(response.Items))
for _, item := range response.Items {
byName[item.Name] = item
}
for _, name := range []string{
"真实数据源",
"BOS 增量扫描",
"目录扫描",
"模型推理",
"X 平台数据集索引",
"采集目录校验",
"JSON 字段提取",
"文本模板渲染",
"JSON 过滤",
"JSON 映射重命名",
"JSON 转 CSV",
"CSV 转 JSON",
"条件分流",
"数据合并",
"视频质检",
"数据过滤",
"视频切片",
"视频标注",
"成品打包",
"抽检采样",
"人工审核",
"MongoDB 写入",
"LeRobot 数据集概览",
"ROSBag 数据概览",
"结果上传",
"Shell 命令执行",
} {
if _, ok := byName[name]; !ok {
t.Fatalf("expected builtin operator %q to be present", name)
}
}
sampling := byName["抽检采样"]
foundRules := false
for _, param := range sampling.Hyperparams {
if param.Key == "RULES_JSON" {
foundRules = true
break
}
}
if !foundRules {
t.Fatalf("expected 抽检采样 to expose RULES_JSON")
}
}
func TestOperatorsListRefreshesBuiltinOperatorImages(t *testing.T) {
t.Setenv("OPERATOR_RUNNER_IMAGE", "ccr-29eug8s3-pub.cnc.bj.baidubce.com/dataflow/droboticflow-operator-runner:20260416-workspacefix-amd64")
ctx := context.Background()
dataStore := store.NewMemoryStore()
item, err := dataStore.CreateOperator(ctx, domain.CreateOperatorInput{
Name: "BOS 增量扫描",
Type: "builtin",
Category: "IO",
Description: "source",
Image: "ccr-29eug8s3-pub.cnc.bj.baidubce.com/dataflow/droboticflow-operator-runner:old",
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "manifest", Type: domain.PortTypeJSON}},
})
if err != nil {
t.Fatalf("create operator: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/operators", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("operators list status: %d body=%s", recorder.Code, recorder.Body.String())
}
stored, err := dataStore.GetOperator(ctx, item.ID)
if err != nil {
t.Fatalf("get operator: %v", err)
}
if stored == nil {
t.Fatalf("expected operator to exist")
}
if stored.Image != "ccr-29eug8s3-pub.cnc.bj.baidubce.com/dataflow/droboticflow-operator-runner:20260416-workspacefix-amd64" {
t.Fatalf("expected builtin operator image to refresh, got %q", stored.Image)
}
}
func TestOperatorsDeleteKeepsBuiltinOperatorDeleted(t *testing.T) {
handler := NewHandler(store.NewMemoryStore(), nil)
listRecorder := httptest.NewRecorder()
handler.ServeHTTP(listRecorder, httptest.NewRequest(http.MethodGet, "/api/operators", nil))
if listRecorder.Code != http.StatusOK {
t.Fatalf("operators list status: %d body=%s", listRecorder.Code, listRecorder.Body.String())
}
var listResponse struct {
Items []domain.OperatorRecord `json:"items"`
}
if err := json.Unmarshal(listRecorder.Body.Bytes(), &listResponse); err != nil {
t.Fatalf("decode operators list: %v", err)
}
var builtin *domain.OperatorRecord
for index := range listResponse.Items {
item := listResponse.Items[index]
if item.Type == "builtin" && item.Name == "真实数据源" {
builtin = &item
break
}
}
if builtin == nil {
t.Fatalf("expected builtin operator to exist before delete")
}
deleteRecorder := httptest.NewRecorder()
handler.ServeHTTP(
deleteRecorder,
httptest.NewRequest(http.MethodDelete, "/api/operators/"+builtin.ID, nil),
)
if deleteRecorder.Code != http.StatusNoContent {
t.Fatalf("delete builtin status: %d body=%s", deleteRecorder.Code, deleteRecorder.Body.String())
}
listAfterDeleteRecorder := httptest.NewRecorder()
handler.ServeHTTP(listAfterDeleteRecorder, httptest.NewRequest(http.MethodGet, "/api/operators", nil))
if listAfterDeleteRecorder.Code != http.StatusOK {
t.Fatalf("operators list after delete status: %d body=%s", listAfterDeleteRecorder.Code, listAfterDeleteRecorder.Body.String())
}
var listAfterDeleteResponse struct {
Items []domain.OperatorRecord `json:"items"`
}
if err := json.Unmarshal(listAfterDeleteRecorder.Body.Bytes(), &listAfterDeleteResponse); err != nil {
t.Fatalf("decode operators list after delete: %v", err)
}
for _, item := range listAfterDeleteResponse.Items {
if item.Name == builtin.Name {
t.Fatalf("expected builtin operator %q to stay deleted", builtin.Name)
}
}
}
func TestDatabaseBrowserListsCollectionsAndQueriesDocuments(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
if _, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "数据库浏览项目",
Description: "用于数据库浏览测试",
}); err != nil {
t.Fatalf("create project: %v", err)
}
if _, err := dataStore.CreateOperator(ctx, domain.CreateOperatorInput{
Name: "JSON 测试算子",
Type: "builtin",
Category: "DATA",
Description: "用于数据库过滤查询测试",
Inputs: []domain.PortDefinition{{ID: "input", Name: "input", Type: domain.PortTypeJSON}},
Outputs: []domain.PortDefinition{{ID: "output", Name: "output", Type: domain.PortTypeJSON}},
}); err != nil {
t.Fatalf("create operator: %v", err)
}
handler := NewHandler(dataStore, nil)
overviewRecorder := httptest.NewRecorder()
handler.ServeHTTP(overviewRecorder, httptest.NewRequest(http.MethodGet, "/api/database?target=platform", nil))
if overviewRecorder.Code != http.StatusOK {
t.Fatalf("database overview status: %d body=%s", overviewRecorder.Code, overviewRecorder.Body.String())
}
var overview struct {
Database string `json:"database"`
Collections []struct {
Name string `json:"name"`
DocumentCount int64 `json:"documentCount"`
} `json:"collections"`
}
if err := json.Unmarshal(overviewRecorder.Body.Bytes(), &overview); err != nil {
t.Fatalf("decode database overview: %v", err)
}
if overview.Database == "" {
t.Fatalf("expected database name in overview response")
}
if len(overview.Collections) == 0 {
t.Fatalf("expected collections in overview response")
}
foundOperatorsCollection := false
for _, item := range overview.Collections {
if item.Name == "operators" {
foundOperatorsCollection = true
if item.DocumentCount < 1 {
t.Fatalf("expected operators collection to have documents, got %d", item.DocumentCount)
}
}
}
if !foundOperatorsCollection {
t.Fatalf("expected operators collection in overview")
}
filter := url.QueryEscape(`{"category":"DATA"}`)
queryRecorder := httptest.NewRecorder()
request := httptest.NewRequest(http.MethodGet, "/api/database/collections/operators/documents?target=platform&filter="+filter+"&limit=10", nil)
handler.ServeHTTP(queryRecorder, request)
if queryRecorder.Code != http.StatusOK {
t.Fatalf("database documents status: %d body=%s", queryRecorder.Code, queryRecorder.Body.String())
}
var result struct {
Collection string `json:"collection"`
Documents []map[string]any `json:"documents"`
Limit int `json:"limit"`
Total int64 `json:"total"`
Filter map[string]any `json:"filter"`
}
if err := json.Unmarshal(queryRecorder.Body.Bytes(), &result); err != nil {
t.Fatalf("decode database documents: %v", err)
}
if result.Collection != "operators" {
t.Fatalf("expected operators collection, got %q", result.Collection)
}
if result.Total < 1 || len(result.Documents) < 1 {
t.Fatalf("expected at least one operator document, total=%d len=%d", result.Total, len(result.Documents))
}
if result.Filter["category"] != "DATA" {
t.Fatalf("expected filter to round-trip, got %#v", result.Filter)
}
}
func TestDatabaseBrowserDefaultsToBusinessTargetWhenUnspecified(t *testing.T) {
handler := NewHandler(store.NewMemoryStore(), nil)
overviewRecorder := httptest.NewRecorder()
handler.ServeHTTP(overviewRecorder, httptest.NewRequest(http.MethodGet, "/api/database", nil))
if overviewRecorder.Code != http.StatusOK {
t.Fatalf("database overview status: %d body=%s", overviewRecorder.Code, overviewRecorder.Body.String())
}
if !strings.Contains(overviewRecorder.Body.String(), `"target":"business"`) {
t.Fatalf("expected default target=business, got %s", overviewRecorder.Body.String())
}
if !strings.Contains(overviewRecorder.Body.String(), `"configured":false`) {
t.Fatalf("expected configured=false for unconfigured business mongo, got %s", overviewRecorder.Body.String())
}
}
func TestDatabaseBrowserUsesMongoConnectionWhenProvided(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateMongoConnection(ctx, domain.CreateMongoConnectionInput{
Name: "业务库",
URI: "mongodb://business.example:27017",
Database: "business",
})
if err != nil {
t.Fatalf("create mongo connection: %v", err)
}
originalResolver := mongoConnectionStoreResolver
t.Cleanup(func() {
mongoConnectionStoreResolver = originalResolver
})
businessStore := store.NewMemoryStore()
if _, err := businessStore.CreateProject(ctx, domain.CreateProjectInput{Name: "业务项目", Description: "业务库"}); err != nil {
t.Fatalf("create business project: %v", err)
}
mongoConnectionStoreResolver = func(_ context.Context, item *domain.MongoConnectionRecord) (databaseBrowserStore, func(), error) {
if item == nil || item.ID != connection.ID || item.URI != "mongodb://business.example:27017" || item.Database != "business" {
t.Fatalf("unexpected mongo connection: %#v", item)
}
return businessStore, func() {}, nil
}
handler := NewHandler(dataStore, nil)
overviewRecorder := httptest.NewRecorder()
handler.ServeHTTP(overviewRecorder, httptest.NewRequest(http.MethodGet, "/api/database?connectionId="+connection.ID, nil))
if overviewRecorder.Code != http.StatusOK {
t.Fatalf("business database overview status: %d body=%s", overviewRecorder.Code, overviewRecorder.Body.String())
}
if !strings.Contains(overviewRecorder.Body.String(), `"target":"business"`) {
t.Fatalf("expected business target in overview, got %s", overviewRecorder.Body.String())
}
if !strings.Contains(overviewRecorder.Body.String(), `"connectionId":"`+connection.ID+`"`) {
t.Fatalf("expected connection id in overview, got %s", overviewRecorder.Body.String())
}
queryRecorder := httptest.NewRecorder()
handler.ServeHTTP(queryRecorder, httptest.NewRequest(http.MethodGet, "/api/database/collections/projects/documents?connectionId="+connection.ID+"&limit=5", nil))
if queryRecorder.Code != http.StatusOK {
t.Fatalf("business database documents status: %d body=%s", queryRecorder.Code, queryRecorder.Body.String())
}
if !strings.Contains(queryRecorder.Body.String(), `"configured":true`) {
t.Fatalf("expected configured=true, got %s", queryRecorder.Body.String())
}
if !strings.Contains(queryRecorder.Body.String(), `"target":"business"`) {
t.Fatalf("expected business target in query result, got %s", queryRecorder.Body.String())
}
}
func TestDatabaseBrowserBusinessCollectionAndDocumentCRUD(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateMongoConnection(ctx, domain.CreateMongoConnectionInput{
Name: "业务写入库",
URI: "mongodb://business.example:27017",
Database: "business",
})
if err != nil {
t.Fatalf("create mongo connection: %v", err)
}
originalResolver := mongoConnectionStoreResolver
t.Cleanup(func() {
mongoConnectionStoreResolver = originalResolver
})
businessStore := store.NewMemoryStore()
mongoConnectionStoreResolver = func(_ context.Context, item *domain.MongoConnectionRecord) (databaseBrowserStore, func(), error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected mongo connection: %#v", item)
}
return businessStore, func() {}, nil
}
handler := NewHandler(dataStore, nil)
connectionQuery := "?connectionId=" + connection.ID
createCollectionRecorder := httptest.NewRecorder()
createCollectionBody := bytes.NewBufferString(`{"name":"orders"}`)
handler.ServeHTTP(
createCollectionRecorder,
httptest.NewRequest(http.MethodPost, "/api/database/collections"+connectionQuery, createCollectionBody),
)
if createCollectionRecorder.Code != http.StatusCreated {
t.Fatalf("create collection status: %d body=%s", createCollectionRecorder.Code, createCollectionRecorder.Body.String())
}
createDocumentRecorder := httptest.NewRecorder()
createDocumentBody := bytes.NewBufferString(`{"document":{"orderNo":"SO-001","status":"new","amount":12}}`)
handler.ServeHTTP(
createDocumentRecorder,
httptest.NewRequest(http.MethodPost, "/api/database/collections/orders/documents"+connectionQuery, createDocumentBody),
)
if createDocumentRecorder.Code != http.StatusCreated {
t.Fatalf("create document status: %d body=%s", createDocumentRecorder.Code, createDocumentRecorder.Body.String())
}
var createdDocument struct {
Collection string `json:"collection"`
Document map[string]any `json:"document"`
}
if err := json.Unmarshal(createDocumentRecorder.Body.Bytes(), &createdDocument); err != nil {
t.Fatalf("decode created document: %v", err)
}
documentID, _ := createdDocument.Document["_id"].(string)
if documentID == "" {
t.Fatalf("expected created document id, got %#v", createdDocument.Document["_id"])
}
queryRecorder := httptest.NewRecorder()
filter := url.QueryEscape(`{"orderNo":"SO-001"}`)
handler.ServeHTTP(
queryRecorder,
httptest.NewRequest(http.MethodGet, "/api/database/collections/orders/documents"+connectionQuery+"&filter="+filter, nil),
)
if queryRecorder.Code != http.StatusOK {
t.Fatalf("query documents status: %d body=%s", queryRecorder.Code, queryRecorder.Body.String())
}
if !strings.Contains(queryRecorder.Body.String(), `"total":1`) {
t.Fatalf("expected one query result, got %s", queryRecorder.Body.String())
}
updateDocumentRecorder := httptest.NewRecorder()
updateDocumentBody := bytes.NewBufferString(`{"document":{"orderNo":"SO-001","status":"done","amount":18}}`)
handler.ServeHTTP(
updateDocumentRecorder,
httptest.NewRequest(http.MethodPut, "/api/database/collections/orders/documents/"+documentID+connectionQuery, updateDocumentBody),
)
if updateDocumentRecorder.Code != http.StatusOK {
t.Fatalf("update document status: %d body=%s", updateDocumentRecorder.Code, updateDocumentRecorder.Body.String())
}
if !strings.Contains(updateDocumentRecorder.Body.String(), `"status":"done"`) {
t.Fatalf("expected updated status in response, got %s", updateDocumentRecorder.Body.String())
}
renameCollectionRecorder := httptest.NewRecorder()
renameCollectionBody := bytes.NewBufferString(`{"newName":"ordersArchive"}`)
handler.ServeHTTP(
renameCollectionRecorder,
httptest.NewRequest(http.MethodPatch, "/api/database/collections/orders"+connectionQuery, renameCollectionBody),
)
if renameCollectionRecorder.Code != http.StatusOK {
t.Fatalf("rename collection status: %d body=%s", renameCollectionRecorder.Code, renameCollectionRecorder.Body.String())
}
if !strings.Contains(renameCollectionRecorder.Body.String(), `"collection":"ordersArchive"`) {
t.Fatalf("expected renamed collection in response, got %s", renameCollectionRecorder.Body.String())
}
deleteDocumentRecorder := httptest.NewRecorder()
handler.ServeHTTP(
deleteDocumentRecorder,
httptest.NewRequest(http.MethodDelete, "/api/database/collections/ordersArchive/documents/"+documentID+connectionQuery, nil),
)
if deleteDocumentRecorder.Code != http.StatusOK {
t.Fatalf("delete document status: %d body=%s", deleteDocumentRecorder.Code, deleteDocumentRecorder.Body.String())
}
deleteCollectionRecorder := httptest.NewRecorder()
handler.ServeHTTP(
deleteCollectionRecorder,
httptest.NewRequest(http.MethodDelete, "/api/database/collections/ordersArchive"+connectionQuery, nil),
)
if deleteCollectionRecorder.Code != http.StatusOK {
t.Fatalf("delete collection status: %d body=%s", deleteCollectionRecorder.Code, deleteCollectionRecorder.Body.String())
}
overviewRecorder := httptest.NewRecorder()
handler.ServeHTTP(overviewRecorder, httptest.NewRequest(http.MethodGet, "/api/database"+connectionQuery, nil))
if overviewRecorder.Code != http.StatusOK {
t.Fatalf("overview status: %d body=%s", overviewRecorder.Code, overviewRecorder.Body.String())
}
if strings.Contains(overviewRecorder.Body.String(), "ordersArchive") {
t.Fatalf("expected deleted collection to be absent, got %s", overviewRecorder.Body.String())
}
}
func TestDatabaseBrowserBusinessIndexCRUD(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateMongoConnection(ctx, domain.CreateMongoConnectionInput{
Name: "业务索引库",
URI: "mongodb://business.example:27017",
Database: "business",
})
if err != nil {
t.Fatalf("create mongo connection: %v", err)
}
originalResolver := mongoConnectionStoreResolver
t.Cleanup(func() {
mongoConnectionStoreResolver = originalResolver
})
businessStore := store.NewMemoryStore()
if _, err := businessStore.CreateDatabaseCollection(ctx, "events"); err != nil {
t.Fatalf("create collection: %v", err)
}
mongoConnectionStoreResolver = func(_ context.Context, item *domain.MongoConnectionRecord) (databaseBrowserStore, func(), error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected mongo connection: %#v", item)
}
return businessStore, func() {}, nil
}
handler := NewHandler(dataStore, nil)
connectionQuery := "?connectionId=" + connection.ID
createIndexRecorder := httptest.NewRecorder()
createIndexBody := bytes.NewBufferString(`{"name":"idx-record-key","keys":{"recordKey":1},"unique":true}`)
handler.ServeHTTP(
createIndexRecorder,
httptest.NewRequest(http.MethodPost, "/api/database/collections/events/indexes"+connectionQuery, createIndexBody),
)
if createIndexRecorder.Code != http.StatusCreated {
t.Fatalf("create index status: %d body=%s", createIndexRecorder.Code, createIndexRecorder.Body.String())
}
if !strings.Contains(createIndexRecorder.Body.String(), `"name":"idx-record-key"`) {
t.Fatalf("expected created index name, got %s", createIndexRecorder.Body.String())
}
listIndexesRecorder := httptest.NewRecorder()
handler.ServeHTTP(
listIndexesRecorder,
httptest.NewRequest(http.MethodGet, "/api/database/collections/events/indexes"+connectionQuery, nil),
)
if listIndexesRecorder.Code != http.StatusOK {
t.Fatalf("list indexes status: %d body=%s", listIndexesRecorder.Code, listIndexesRecorder.Body.String())
}
if !strings.Contains(listIndexesRecorder.Body.String(), `"idx-record-key"`) {
t.Fatalf("expected created index in list, got %s", listIndexesRecorder.Body.String())
}
deleteIndexRecorder := httptest.NewRecorder()
handler.ServeHTTP(
deleteIndexRecorder,
httptest.NewRequest(http.MethodDelete, "/api/database/collections/events/indexes/idx-record-key"+connectionQuery, nil),
)
if deleteIndexRecorder.Code != http.StatusOK {
t.Fatalf("delete index status: %d body=%s", deleteIndexRecorder.Code, deleteIndexRecorder.Body.String())
}
if strings.Contains(deleteIndexRecorder.Body.String(), `"deleted":false`) {
t.Fatalf("expected index deletion success, got %s", deleteIndexRecorder.Body.String())
}
}
func TestMongoConnectionsTestEndpointUsesDraftOrStoredConnection(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
storedConnection, err := dataStore.CreateMongoConnection(ctx, domain.CreateMongoConnectionInput{
Name: "业务测试库",
URI: "mongodb://business.example:27017",
Database: "business",
})
if err != nil {
t.Fatalf("create mongo connection: %v", err)
}
originalResolver := mongoConnectionStoreResolver
t.Cleanup(func() {
mongoConnectionStoreResolver = originalResolver
})
probeStore := store.NewMemoryStore()
if _, err := probeStore.CreateDatabaseCollection(ctx, "probeCollection"); err != nil {
t.Fatalf("create probe collection: %v", err)
}
mongoConnectionStoreResolver = func(_ context.Context, item *domain.MongoConnectionRecord) (databaseBrowserStore, func(), error) {
if item == nil {
t.Fatalf("expected mongo connection")
}
return probeStore, func() {}, nil
}
handler := NewHandler(dataStore, nil)
draftRecorder := httptest.NewRecorder()
draftBody := bytes.NewBufferString(`{"uri":"mongodb://draft.example:27017","database":"draft-db"}`)
handler.ServeHTTP(draftRecorder, httptest.NewRequest(http.MethodPost, "/api/mongo/connections/test", draftBody))
if draftRecorder.Code != http.StatusOK {
t.Fatalf("draft connection test status: %d body=%s", draftRecorder.Code, draftRecorder.Body.String())
}
if !strings.Contains(draftRecorder.Body.String(), `"probeCollection"`) {
t.Fatalf("expected probe collection in test response, got %s", draftRecorder.Body.String())
}
storedRecorder := httptest.NewRecorder()
storedBody := bytes.NewBufferString(`{"id":"` + storedConnection.ID + `"}`)
handler.ServeHTTP(storedRecorder, httptest.NewRequest(http.MethodPost, "/api/mongo/connections/test", storedBody))
if storedRecorder.Code != http.StatusOK {
t.Fatalf("stored connection test status: %d body=%s", storedRecorder.Code, storedRecorder.Body.String())
}
if !strings.Contains(storedRecorder.Body.String(), `"connectionId":"`+storedConnection.ID+`"`) {
t.Fatalf("expected stored connection id in response, got %s", storedRecorder.Body.String())
}
}
func TestRunsListReturnsSummaryPayload(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
run := domain.RunRecord{
ID: "run-summary-1",
WorkflowID: "workflow-1",
WorkflowName: "Summary Workflow",
ProjectID: "project-1",
ProjectName: "Summary Project",
Trigger: domain.RunTriggerScheduled,
Status: domain.RunStatusRunning,
CurrentNodeID: "node-quality",
NodeExecutions: []domain.NodeExecutionRecord{
{
NodeID: "node-quality",
NodeLabel: "视频质检",
Status: domain.NodeExecutionStatusRunning,
Logs: []domain.LogEntryRecord{
{Timestamp: "2026-04-13T01:00:00Z", Level: "INFO", Message: "heavy node log"},
},
Artifacts: []domain.ExecutionArtifact{
{ID: "artifact-1", RunID: "run-summary-1", NodeID: "node-quality", Name: "quality-report.json", Type: domain.PortTypeJSON, Size: "2 KB", Path: "/tmp/quality-report.json"},
},
ResourceSeries: []domain.ResourceSample{
{Timestamp: "2026-04-13T01:00:00Z", CPU: 90, Memory: 1024},
},
},
},
Logs: []domain.LogEntryRecord{
{Timestamp: "2026-04-13T01:00:00Z", Level: "INFO", Message: "top level log"},
},
ResourceSeries: []domain.ResourceSample{
{Timestamp: "2026-04-13T01:00:00Z", CPU: 80, Memory: 2048},
},
Artifacts: []domain.ExecutionArtifact{
{ID: "artifact-2", RunID: "run-summary-1", NodeID: "node-quality", Name: "clip.mp4", Type: domain.PortTypeVideo, Size: "120 MB", Path: "/tmp/clip.mp4"},
},
K8sRefs: []domain.K8sRef{
{NodeID: "node-quality", JobName: "quality-job", Namespace: "droboticflow"},
},
CreatedAt: "2026-04-13T01:00:00Z",
UpdatedAt: "2026-04-13T01:00:00Z",
}
if err := dataStore.UpsertRun(ctx, run); err != nil {
t.Fatalf("upsert run: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/runs", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("runs list status: %d body=%s", recorder.Code, recorder.Body.String())
}
body := recorder.Body.String()
for _, forbidden := range []string{"\"logs\"", "\"artifacts\"", "\"resourceSeries\"", "\"nodeExecutions\"", "\"k8sRefs\""} {
if strings.Contains(body, forbidden) {
t.Fatalf("runs list should not include %s in summary payload: %s", forbidden, body)
}
}
var response struct {
Items []map[string]any `json:"items"`
}
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode runs response: %v", err)
}
if len(response.Items) != 1 {
t.Fatalf("expected 1 run summary, got %d", len(response.Items))
}
if response.Items[0]["id"] != run.ID {
t.Fatalf("summary id = %v, want %s", response.Items[0]["id"], run.ID)
}
if response.Items[0]["currentNodeId"] != run.CurrentNodeID {
t.Fatalf("summary currentNodeId = %v, want %s", response.Items[0]["currentNodeId"], run.CurrentNodeID)
}
}
func TestWorkflowRunsListReturnsWorkflowOnlySummaries(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{Name: "历史项目", Description: "history"})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflowA, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "周期工作流 A",
Description: "a",
Type: domain.WorkflowTypeStreaming,
Schedule: &domain.WorkflowSchedule{IntervalHours: 2, Mode: domain.WorkflowScheduleModeEveryHours},
Nodes: []domain.WorkflowNode{},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflowA: %v", err)
}
workflowB, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "周期工作流 B",
Description: "b",
Type: domain.WorkflowTypeStreaming,
Schedule: &domain.WorkflowSchedule{IntervalHours: 3, Mode: domain.WorkflowScheduleModeEveryHours},
Nodes: []domain.WorkflowNode{},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflowB: %v", err)
}
if err := dataStore.UpsertRun(ctx, domain.RunRecord{
ID: "run-a1",
WorkflowID: workflowA.ID,
WorkflowName: workflowA.Name,
ProjectID: project.ID,
ProjectName: project.Name,
Trigger: domain.RunTriggerScheduled,
Status: domain.RunStatusCompleted,
CreatedAt: "2026-04-22T01:00:00Z",
UpdatedAt: "2026-04-22T01:00:00Z",
NodeExecutions: []domain.NodeExecutionRecord{},
Logs: []domain.LogEntryRecord{},
ResourceSeries: []domain.ResourceSample{},
Artifacts: []domain.ExecutionArtifact{},
K8sRefs: []domain.K8sRef{},
}); err != nil {
t.Fatalf("upsert workflowA run: %v", err)
}
if err := dataStore.UpsertRun(ctx, domain.RunRecord{
ID: "run-b1",
WorkflowID: workflowB.ID,
WorkflowName: workflowB.Name,
ProjectID: project.ID,
ProjectName: project.Name,
Trigger: domain.RunTriggerScheduled,
Status: domain.RunStatusFailed,
CreatedAt: "2026-04-22T02:00:00Z",
UpdatedAt: "2026-04-22T02:00:00Z",
NodeExecutions: []domain.NodeExecutionRecord{},
Logs: []domain.LogEntryRecord{},
ResourceSeries: []domain.ResourceSample{},
Artifacts: []domain.ExecutionArtifact{},
K8sRefs: []domain.K8sRef{},
}); err != nil {
t.Fatalf("upsert workflowB run: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/workflows/"+workflowA.ID+"/runs", nil))
if recorder.Code != http.StatusOK {
t.Fatalf("workflow runs list status: %d body=%s", recorder.Code, recorder.Body.String())
}
var response struct {
Items []domain.RunSummary `json:"items"`
}
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatalf("decode workflow runs: %v", err)
}
if len(response.Items) != 1 {
t.Fatalf("expected 1 workflow run summary, got %d", len(response.Items))
}
if response.Items[0].ID != "run-a1" {
t.Fatalf("expected workflowA run summary, got %#v", response.Items[0])
}
}
func TestRunsRerunSubtreeCreatesQueuedChildRunWithBaseline(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{Name: "补跑项目", Description: "rerun"})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "失败补跑工作流",
Description: "rerun subtree",
Type: domain.WorkflowTypeBatch,
Nodes: []domain.WorkflowNode{
{ID: "a", Type: "operator", Data: domain.WorkflowNodeData{Label: "A", Category: "DATA", Description: "a"}},
{ID: "b", Type: "operator", Data: domain.WorkflowNodeData{Label: "B", Category: "DATA", Description: "b"}},
{ID: "c", Type: "operator", Data: domain.WorkflowNodeData{Label: "C", Category: "DATA", Description: "c"}},
{ID: "d", Type: "operator", Data: domain.WorkflowNodeData{Label: "D", Category: "DATA", Description: "d"}},
},
Edges: []domain.WorkflowEdge{
{ID: "a-b", Source: "a", Target: "b"},
{ID: "b-d", Source: "b", Target: "d"},
{ID: "c-d", Source: "c", Target: "d"},
},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
sourceRun := domain.RunRecord{
ID: "run-failed-1",
WorkflowID: workflow.ID,
WorkflowName: workflow.Name,
ProjectID: project.ID,
ProjectName: project.Name,
Trigger: domain.RunTriggerScheduled,
Status: domain.RunStatusFailed,
CurrentNodeID: "b",
NodeExecutions: []domain.NodeExecutionRecord{
{NodeID: "a", NodeLabel: "A", Status: domain.NodeExecutionStatusCompleted, Logs: []domain.LogEntryRecord{{Message: "a ok"}}, Artifacts: []domain.ExecutionArtifact{{ID: "artifact-a", Name: "a.json"}}},
{NodeID: "c", NodeLabel: "C", Status: domain.NodeExecutionStatusCompleted, Logs: []domain.LogEntryRecord{{Message: "c ok"}}, Artifacts: []domain.ExecutionArtifact{{ID: "artifact-c", Name: "c.json"}}},
{NodeID: "b", NodeLabel: "B", Status: domain.NodeExecutionStatusFailed, Error: "boom"},
},
CreatedAt: "2026-04-22T03:00:00Z",
UpdatedAt: "2026-04-22T03:05:00Z",
}
if err := dataStore.UpsertRun(ctx, sourceRun); err != nil {
t.Fatalf("upsert source run: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
body := bytes.NewBufferString(`{"nodeId":"b"}`)
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/api/runs/"+sourceRun.ID+"/rerun-subtree", body))
if recorder.Code != http.StatusAccepted {
t.Fatalf("rerun subtree status: %d body=%s", recorder.Code, recorder.Body.String())
}
var child domain.RunRecord
if err := json.Unmarshal(recorder.Body.Bytes(), &child); err != nil {
t.Fatalf("decode child run: %v", err)
}
if child.Trigger != domain.RunTriggerRerunSubtree {
t.Fatalf("expected rerun_subtree trigger, got %s", child.Trigger)
}
if child.ParentRunID != sourceRun.ID {
t.Fatalf("expected parent run %s, got %s", sourceRun.ID, child.ParentRunID)
}
if child.RestartFromNodeID != "b" {
t.Fatalf("expected restartFromNodeId=b, got %s", child.RestartFromNodeID)
}
if child.Status != domain.RunStatusQueued {
t.Fatalf("expected queued child run, got %s", child.Status)
}
if len(child.NodeExecutions) != 2 {
t.Fatalf("expected 2 baseline executions, got %#v", child.NodeExecutions)
}
nodeIDs := []string{child.NodeExecutions[0].NodeID, child.NodeExecutions[1].NodeID}
sort.Strings(nodeIDs)
if strings.Join(nodeIDs, ",") != "a,c" {
t.Fatalf("expected baseline nodes a,c, got %v", nodeIDs)
}
}
func TestRunsRerunSubtreeRejectsMissingCompletedBaseline(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{Name: "补跑项目", Description: "rerun"})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "失败补跑工作流",
Description: "rerun subtree",
Type: domain.WorkflowTypeBatch,
Nodes: []domain.WorkflowNode{
{ID: "a", Type: "operator", Data: domain.WorkflowNodeData{Label: "A", Category: "DATA", Description: "a"}},
{ID: "b", Type: "operator", Data: domain.WorkflowNodeData{Label: "B", Category: "DATA", Description: "b"}},
{ID: "c", Type: "operator", Data: domain.WorkflowNodeData{Label: "C", Category: "DATA", Description: "c"}},
{ID: "d", Type: "operator", Data: domain.WorkflowNodeData{Label: "D", Category: "DATA", Description: "d"}},
},
Edges: []domain.WorkflowEdge{
{ID: "a-b", Source: "a", Target: "b"},
{ID: "b-d", Source: "b", Target: "d"},
{ID: "c-d", Source: "c", Target: "d"},
},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
sourceRun := domain.RunRecord{
ID: "run-failed-2",
WorkflowID: workflow.ID,
WorkflowName: workflow.Name,
ProjectID: project.ID,
ProjectName: project.Name,
Trigger: domain.RunTriggerScheduled,
Status: domain.RunStatusFailed,
CurrentNodeID: "b",
NodeExecutions: []domain.NodeExecutionRecord{
{NodeID: "a", NodeLabel: "A", Status: domain.NodeExecutionStatusCompleted},
{NodeID: "c", NodeLabel: "C", Status: domain.NodeExecutionStatusFailed, Error: "side branch failed"},
{NodeID: "b", NodeLabel: "B", Status: domain.NodeExecutionStatusFailed, Error: "boom"},
},
CreatedAt: "2026-04-22T03:00:00Z",
UpdatedAt: "2026-04-22T03:05:00Z",
}
if err := dataStore.UpsertRun(ctx, sourceRun); err != nil {
t.Fatalf("upsert source run: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
body := bytes.NewBufferString(`{"nodeId":"b"}`)
handler.ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/api/runs/"+sourceRun.ID+"/rerun-subtree", body))
if recorder.Code != http.StatusConflict {
t.Fatalf("expected 409 for invalid baseline, got %d body=%s", recorder.Code, recorder.Body.String())
}
}
func TestWorkflowNodeSourceStateEndpointsExposeAndResetCommittedState(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
Name: "扫描状态工作流",
Description: "scan source state",
Type: domain.WorkflowTypeBatch,
Kind: domain.WorkflowKindScan,
ScanConfig: &domain.ScanConfig{
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test/source-a",
Bucket: "datastorage",
Prefix: "algo/X-platform-test/source-a",
ScanMode: "INCREMENTAL",
},
Nodes: []domain.WorkflowNode{
{
ID: "scan-source",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "BOS 增量扫描",
Category: "IO",
Description: "source",
},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
currentFingerprint := domain.ComputeSourceFingerprint(domain.SourceFingerprintInput{
ScanMode: "INCREMENTAL",
IncrementalUnit: "OBJECT",
DirectoryDepth: 1,
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test/source-a",
Bucket: "datastorage",
Prefix: "algo/X-platform-test/source-a",
})
legacyFingerprint := domain.ComputeSourceFingerprint(domain.SourceFingerprintInput{
ScanMode: "INCREMENTAL",
IncrementalUnit: "OBJECT",
DirectoryDepth: 1,
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test/source-legacy",
Bucket: "datastorage",
Prefix: "algo/X-platform-test/source-legacy",
})
if err := dataStore.UpsertSourceState(ctx, domain.SourceStateRecord{
ID: workflow.ID + ":scan-source:" + legacyFingerprint,
WorkflowID: workflow.ID,
NodeID: "scan-source",
SourceFingerprint: legacyFingerprint,
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test/source-legacy",
Bucket: "datastorage",
Prefix: "algo/X-platform-test/source-legacy",
ScanMode: "INCREMENTAL",
IncrementalUnit: "OBJECT",
DirectoryDepth: 1,
SeenFingerprints: []string{"legacy-1"},
LastRunID: "run-legacy",
LastListedCount: 3,
LastNewCount: 1,
LastScanCompletedAt: "2026-04-12T00:00:00Z",
UpdatedAt: "2026-04-12T00:00:01Z",
}); err != nil {
t.Fatalf("seed legacy source state: %v", err)
}
if err := dataStore.UpsertSourceState(ctx, domain.SourceStateRecord{
ID: workflow.ID + ":scan-source:" + currentFingerprint,
WorkflowID: workflow.ID,
NodeID: "scan-source",
SourceFingerprint: currentFingerprint,
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test/source-a",
Bucket: "datastorage",
Prefix: "algo/X-platform-test/source-a",
ScanMode: "INCREMENTAL",
IncrementalUnit: "OBJECT",
DirectoryDepth: 1,
SeenFingerprints: []string{"entry-1", "entry-2"},
LastRunID: "run-current",
LastListedCount: 8,
LastNewCount: 2,
LastScanCompletedAt: "2026-04-12T01:00:00Z",
UpdatedAt: "2026-04-12T01:00:01Z",
}); err != nil {
t.Fatalf("seed current source state: %v", err)
}
handler := NewHandler(dataStore, nil)
getRecorder := httptest.NewRecorder()
handler.ServeHTTP(getRecorder, httptest.NewRequest(http.MethodGet, "/api/workflows/"+workflow.ID+"/nodes/scan-source/source-state", nil))
if getRecorder.Code != http.StatusOK {
t.Fatalf("source state get status: %d body=%s", getRecorder.Code, getRecorder.Body.String())
}
var body workflowNodeSourceStateResponse
if err := json.Unmarshal(getRecorder.Body.Bytes(), &body); err != nil {
t.Fatalf("decode source state response: %v", err)
}
if !body.Supported || !body.Stateful {
t.Fatalf("expected supported stateful response, got %+v", body)
}
if body.Current == nil || body.Current.LastRunID != "run-current" {
t.Fatalf("expected current source state, got %+v", body.Current)
}
if body.CurrentFingerprint != currentFingerprint {
t.Fatalf("expected current fingerprint %s, got %s", currentFingerprint, body.CurrentFingerprint)
}
if len(body.Versions) != 2 {
t.Fatalf("expected 2 source state versions, got %+v", body.Versions)
}
if body.Versions[0].LastRunID != "run-current" {
t.Fatalf("expected latest source state first, got %+v", body.Versions)
}
deleteRecorder := httptest.NewRecorder()
handler.ServeHTTP(deleteRecorder, httptest.NewRequest(http.MethodDelete, "/api/workflows/"+workflow.ID+"/nodes/scan-source/source-state", nil))
if deleteRecorder.Code != http.StatusNoContent {
t.Fatalf("source state delete status: %d body=%s", deleteRecorder.Code, deleteRecorder.Body.String())
}
stored, err := dataStore.GetSourceState(ctx, workflow.ID, "scan-source", currentFingerprint)
if err != nil {
t.Fatalf("get deleted current state: %v", err)
}
if stored != nil {
t.Fatalf("expected current source state removed, got %+v", stored)
}
legacyStored, err := dataStore.GetSourceState(ctx, workflow.ID, "scan-source", legacyFingerprint)
if err != nil {
t.Fatalf("get legacy source state: %v", err)
}
if legacyStored == nil {
t.Fatalf("expected legacy source state to remain")
}
}
func TestWorkflowNodeSourceStateEndpointsSupportDedicatedBosScanOperatorNodes(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
Name: "BOS 扫描状态工作流",
Description: "dedicated bos scan state",
Type: domain.WorkflowTypeBatch,
Kind: domain.WorkflowKindScan,
ScanConfig: &domain.ScanConfig{
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test",
Bucket: "datastorage",
Prefix: "algo/X-platform-test",
ScanMode: "INCREMENTAL",
},
Nodes: []domain.WorkflowNode{
{
ID: "node-bos-scan",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "BOS 增量扫描",
Category: "IO",
Description: "source",
},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
currentFingerprint := domain.ComputeSourceFingerprint(domain.SourceFingerprintInput{
ScanMode: "INCREMENTAL",
IncrementalUnit: "OBJECT",
DirectoryDepth: 1,
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test",
Bucket: "datastorage",
Prefix: "algo/X-platform-test",
})
if err := dataStore.UpsertSourceState(ctx, domain.SourceStateRecord{
ID: workflow.ID + ":node-bos-scan:" + currentFingerprint,
WorkflowID: workflow.ID,
NodeID: "node-bos-scan",
SourceFingerprint: currentFingerprint,
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test",
Bucket: "datastorage",
Prefix: "algo/X-platform-test",
ScanMode: "INCREMENTAL",
IncrementalUnit: "OBJECT",
DirectoryDepth: 1,
SeenFingerprints: []string{"entry-1"},
LastRunID: "run-bos-current",
LastListedCount: 6,
LastNewCount: 1,
LastScanCompletedAt: "2026-04-12T02:00:00Z",
UpdatedAt: "2026-04-12T02:00:01Z",
}); err != nil {
t.Fatalf("seed bos source state: %v", err)
}
handler := NewHandler(dataStore, nil)
getRecorder := httptest.NewRecorder()
handler.ServeHTTP(getRecorder, httptest.NewRequest(http.MethodGet, "/api/workflows/"+workflow.ID+"/nodes/node-bos-scan/source-state", nil))
if getRecorder.Code != http.StatusOK {
t.Fatalf("source state get status: %d body=%s", getRecorder.Code, getRecorder.Body.String())
}
var body workflowNodeSourceStateResponse
if err := json.Unmarshal(getRecorder.Body.Bytes(), &body); err != nil {
t.Fatalf("decode source state response: %v", err)
}
if !body.Supported || !body.Stateful {
t.Fatalf("expected supported stateful response, got %+v", body)
}
if body.Current == nil || body.Current.LastRunID != "run-bos-current" {
t.Fatalf("expected current bos source state, got %+v", body.Current)
}
if body.CurrentFingerprint != currentFingerprint {
t.Fatalf("expected current fingerprint %s, got %s", currentFingerprint, body.CurrentFingerprint)
}
}
func TestUserStoragePathFavoritesAPIStoresNormalizedFavoritesWithoutLeakingToUsersList(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
user, err := dataStore.CreateUser(ctx, domain.CreateUserInput{
Name: "收藏用户",
Email: "favorite-user@example.com",
Role: domain.UserRoleOperator,
})
if err != nil {
t.Fatalf("create user: %v", err)
}
handler := NewHandler(dataStore, nil)
updatePayload := []byte(`{
"items": [
{"scopeKey":"connection:storage-a","bucket":"datastorage","prefix":"algo/X-platform-test","label":" "},
{"scopeKey":"connection:storage-a","bucket":"datastorage","prefix":"algo/X-platform-test/","label":"重复"},
{"scopeKey":"connection:storage-a","bucket":"datastorage","prefix":"processed"},
{"scopeKey":"","bucket":"datastorage","prefix":"invalid"},
{"scopeKey":"source:bos://datastorage/root","bucket":"archive","prefix":" clips "}
]
}`)
updateRecorder := httptest.NewRecorder()
handler.ServeHTTP(
updateRecorder,
httptest.NewRequest(http.MethodPut, "/api/users/"+user.ID+"/storage-path-favorites", bytes.NewReader(updatePayload)),
)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("favorites update status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
var updateBody struct {
Items []domain.StoragePathFavoriteRecord `json:"items"`
}
if err := json.Unmarshal(updateRecorder.Body.Bytes(), &updateBody); err != nil {
t.Fatalf("decode favorites update: %v", err)
}
expected := []domain.StoragePathFavoriteRecord{
{
ScopeKey: "connection:storage-a",
Bucket: "datastorage",
Prefix: "algo/X-platform-test",
Label: "datastorage/algo/X-platform-test",
},
{
ScopeKey: "connection:storage-a",
Bucket: "datastorage",
Prefix: "processed",
Label: "datastorage/processed",
},
{
ScopeKey: "source:bos://datastorage/root",
Bucket: "archive",
Prefix: "clips",
Label: "archive/clips",
},
}
if got, want := len(updateBody.Items), len(expected); got != want {
t.Fatalf("favorites count = %d, want %d", got, want)
}
for index := range expected {
if updateBody.Items[index] != expected[index] {
t.Fatalf("favorite[%d] = %#v, want %#v", index, updateBody.Items[index], expected[index])
}
}
getRecorder := httptest.NewRecorder()
handler.ServeHTTP(
getRecorder,
httptest.NewRequest(http.MethodGet, "/api/users/"+user.ID+"/storage-path-favorites", nil),
)
if getRecorder.Code != http.StatusOK {
t.Fatalf("favorites get status: %d body=%s", getRecorder.Code, getRecorder.Body.String())
}
var getBody struct {
Items []domain.StoragePathFavoriteRecord `json:"items"`
}
if err := json.Unmarshal(getRecorder.Body.Bytes(), &getBody); err != nil {
t.Fatalf("decode favorites get: %v", err)
}
if strings.Join(func() []string {
values := make([]string, 0, len(getBody.Items))
for _, item := range getBody.Items {
values = append(values, item.ScopeKey+"|"+item.Bucket+"|"+item.Prefix+"|"+item.Label)
}
return values
}(), "\n") != strings.Join(func() []string {
values := make([]string, 0, len(expected))
for _, item := range expected {
values = append(values, item.ScopeKey+"|"+item.Bucket+"|"+item.Prefix+"|"+item.Label)
}
return values
}(), "\n") {
t.Fatalf("favorites get body = %#v, want %#v", getBody.Items, expected)
}
usersRecorder := httptest.NewRecorder()
handler.ServeHTTP(usersRecorder, httptest.NewRequest(http.MethodGet, "/api/users", nil))
if usersRecorder.Code != http.StatusOK {
t.Fatalf("users list status: %d body=%s", usersRecorder.Code, usersRecorder.Body.String())
}
if strings.Contains(usersRecorder.Body.String(), "storagePathFavorites") {
t.Fatalf("expected users list to omit storagePathFavorites, got %s", usersRecorder.Body.String())
}
storedUser, err := dataStore.GetUser(ctx, user.ID)
if err != nil {
t.Fatalf("get stored user: %v", err)
}
if storedUser == nil || len(storedUser.StoragePathFavorites) != len(expected) {
t.Fatalf("stored favorites = %#v, want %#v", storedUser, expected)
}
}
func TestProjectStoragePathFavoritesAPIStoresNormalizedFavoritesWithoutLeakingToProjectResponses(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "共享收藏项目",
Description: "project favorites",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
updatePayload := []byte(`{
"items": [
{"scopeKey":"connection:storage-a","bucket":"datastorage","prefix":"algo/X-platform-test"},
{"scopeKey":"connection:storage-a","bucket":"datastorage","prefix":"algo/X-platform-test/"},
{"scopeKey":"connection:storage-a","bucket":"datastorage","prefix":"processed"},
{"scopeKey":"source:bos://datastorage/root","bucket":"archive","prefix":" clips "}
]
}`)
updateRecorder := httptest.NewRecorder()
handler.ServeHTTP(
updateRecorder,
httptest.NewRequest(http.MethodPut, "/api/projects/"+project.ID+"/storage-path-favorites", bytes.NewReader(updatePayload)),
)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("project favorites update status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
var updateBody struct {
Items []domain.StoragePathFavoriteRecord `json:"items"`
}
if err := json.Unmarshal(updateRecorder.Body.Bytes(), &updateBody); err != nil {
t.Fatalf("decode project favorites update: %v", err)
}
if len(updateBody.Items) != 3 {
t.Fatalf("expected 3 normalized project favorites, got %#v", updateBody.Items)
}
getRecorder := httptest.NewRecorder()
handler.ServeHTTP(
getRecorder,
httptest.NewRequest(http.MethodGet, "/api/projects/"+project.ID+"/storage-path-favorites", nil),
)
if getRecorder.Code != http.StatusOK {
t.Fatalf("project favorites get status: %d body=%s", getRecorder.Code, getRecorder.Body.String())
}
if strings.Contains(getRecorder.Body.String(), "\"prefix\":\"clips \"") {
t.Fatalf("expected project favorites prefix to be normalized, got %s", getRecorder.Body.String())
}
projectGetRecorder := httptest.NewRecorder()
handler.ServeHTTP(projectGetRecorder, httptest.NewRequest(http.MethodGet, "/api/projects/"+project.ID, nil))
if projectGetRecorder.Code != http.StatusOK {
t.Fatalf("project get status: %d body=%s", projectGetRecorder.Code, projectGetRecorder.Body.String())
}
if strings.Contains(projectGetRecorder.Body.String(), "storagePathFavorites") {
t.Fatalf("expected project get to omit storagePathFavorites, got %s", projectGetRecorder.Body.String())
}
projectsListRecorder := httptest.NewRecorder()
handler.ServeHTTP(projectsListRecorder, httptest.NewRequest(http.MethodGet, "/api/projects", nil))
if projectsListRecorder.Code != http.StatusOK {
t.Fatalf("projects list status: %d body=%s", projectsListRecorder.Code, projectsListRecorder.Body.String())
}
if strings.Contains(projectsListRecorder.Body.String(), "storagePathFavorites") {
t.Fatalf("expected projects list to omit storagePathFavorites, got %s", projectsListRecorder.Body.String())
}
}
func TestSettingsAIConfigurationDrivesAIStatus(t *testing.T) {
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
settingsPayload := []byte(`{
"k8s": {
"endpoint": "https://120.48.161.230:6443",
"namespace": "droboticflow",
"workspacePVCName": "droboticflow-workspace",
"workspaceMountPath": "/workspace",
"kubeconfig": "apiVersion: v1\nkind: Config"
},
"ai": {
"provider": "dashscope-openai-compatible",
"baseURL": "https://coding.dashscope.aliyuncs.com/v1",
"model": "glm-5",
"apiKey": "test-key"
},
"businessMongo": {
"uri": "mongodb://business-user:business-pass@business.example:27017/?authSource=admin",
"database": "business_data"
},
"timezone": "Asia/Tokyo"
}`)
updateRecorder := httptest.NewRecorder()
updateRequest := httptest.NewRequest(http.MethodPut, "/api/settings", bytes.NewReader(settingsPayload))
handler.ServeHTTP(updateRecorder, updateRequest)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("settings update status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
statusRecorder := httptest.NewRecorder()
handler.ServeHTTP(statusRecorder, httptest.NewRequest(http.MethodGet, "/api/ai/status", nil))
if statusRecorder.Code != http.StatusOK {
t.Fatalf("ai status code: %d body=%s", statusRecorder.Code, statusRecorder.Body.String())
}
var statusBody struct {
Enabled bool `json:"enabled"`
BaseURL string `json:"baseURL"`
Model string `json:"model"`
Provider string `json:"provider"`
}
if err := json.Unmarshal(statusRecorder.Body.Bytes(), &statusBody); err != nil {
t.Fatalf("decode ai status: %v", err)
}
if !statusBody.Enabled {
t.Fatalf("expected ai status enabled")
}
if statusBody.Model != "glm-5" {
t.Fatalf("unexpected model: %s", statusBody.Model)
}
if statusBody.BaseURL != "https://coding.dashscope.aliyuncs.com/v1" {
t.Fatalf("unexpected baseURL: %s", statusBody.BaseURL)
}
settingsRecorder := httptest.NewRecorder()
handler.ServeHTTP(settingsRecorder, httptest.NewRequest(http.MethodGet, "/api/settings", nil))
if settingsRecorder.Code != http.StatusOK {
t.Fatalf("settings get status: %d body=%s", settingsRecorder.Code, settingsRecorder.Body.String())
}
var settingsBody struct {
K8s struct {
WorkspacePVCName string `json:"workspacePVCName"`
WorkspaceMountPath string `json:"workspaceMountPath"`
Kubeconfig string `json:"kubeconfig"`
KubeconfigPreview string `json:"kubeconfigPreview"`
HasKubeconfig bool `json:"hasKubeconfig"`
} `json:"k8s"`
AI struct {
APIKey string `json:"apiKey"`
APIKeyPreview string `json:"apiKeyPreview"`
HasAPIKey bool `json:"hasAPIKey"`
} `json:"ai"`
BusinessMongo struct {
URI string `json:"uri"`
URIPreview string `json:"uriPreview"`
HasURI bool `json:"hasUri"`
Database string `json:"database"`
} `json:"businessMongo"`
Timezone string `json:"timezone"`
Storage any `json:"storage"`
}
if err := json.Unmarshal(settingsRecorder.Body.Bytes(), &settingsBody); err != nil {
t.Fatalf("decode settings: %v", err)
}
if settingsBody.K8s.Kubeconfig != "" {
t.Fatalf("expected settings kubeconfig to be sanitized, got %q", settingsBody.K8s.Kubeconfig)
}
if !settingsBody.K8s.HasKubeconfig {
t.Fatalf("expected hasKubeconfig to be true")
}
if settingsBody.K8s.KubeconfigPreview == "" {
t.Fatalf("expected kubeconfig preview to be returned")
}
if settingsBody.K8s.WorkspacePVCName != "droboticflow-workspace" {
t.Fatalf("expected workspace pvc name to roundtrip, got %q", settingsBody.K8s.WorkspacePVCName)
}
if settingsBody.K8s.WorkspaceMountPath != "/workspace" {
t.Fatalf("expected workspace mount path to roundtrip, got %q", settingsBody.K8s.WorkspaceMountPath)
}
if settingsBody.AI.APIKey != "" {
t.Fatalf("expected settings apiKey to be sanitized")
}
if !settingsBody.AI.HasAPIKey {
t.Fatalf("expected hasAPIKey to be true")
}
if settingsBody.AI.APIKeyPreview != "te****ey" {
t.Fatalf("expected apiKey preview to be masked, got %q", settingsBody.AI.APIKeyPreview)
}
if settingsBody.BusinessMongo.URI != "" {
t.Fatalf("expected business mongo uri to be sanitized")
}
if !settingsBody.BusinessMongo.HasURI {
t.Fatalf("expected hasUri to be true for business mongo")
}
if settingsBody.BusinessMongo.URIPreview == "" {
t.Fatalf("expected business mongo uri preview to be returned")
}
if settingsBody.BusinessMongo.Database != "business_data" {
t.Fatalf("expected business mongo database to roundtrip, got %q", settingsBody.BusinessMongo.Database)
}
if settingsBody.Timezone != "Asia/Tokyo" {
t.Fatalf("expected timezone to roundtrip, got %q", settingsBody.Timezone)
}
if settingsBody.Storage != nil {
t.Fatalf("expected storage to be omitted from settings response")
}
}
func TestTemplateExecutionConfigValidationAndPersistence(t *testing.T) {
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"执行保障模板",
"description":"template execution config",
"type":"streaming",
"hyperparams":[{"key":"GLOBAL_ENV","value":"template-create"}],
"maxConcurrentRuns":2,
"nodeTimeoutSeconds":12,
"runTimeoutSeconds":34,
"maxRetryAttempts":1,
"retryBackoffSeconds":56,
"schedule":{
"interval":90,
"sourcePath":"oss://incoming"
},
"nodes":[],
"edges":[]
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/templates", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("template create status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created map[string]any
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created template: %v", err)
}
if created["type"].(string) != "streaming" {
t.Fatalf("expected streaming type, got %v", created["type"])
}
if created["retryBackoffSeconds"].(float64) != 56 {
t.Fatalf("expected retryBackoffSeconds=56, got %v", created["retryBackoffSeconds"])
}
createdHyperparams := created["hyperparams"].([]any)
if len(createdHyperparams) != 1 || createdHyperparams[0].(map[string]any)["value"].(string) != "template-create" {
t.Fatalf("expected template hyperparams to persist on create, got %#v", created["hyperparams"])
}
templateID := created["id"].(string)
getRecorder := httptest.NewRecorder()
handler.ServeHTTP(getRecorder, httptest.NewRequest(http.MethodGet, "/api/templates/"+templateID, nil))
if getRecorder.Code != http.StatusOK {
t.Fatalf("template get status: %d body=%s", getRecorder.Code, getRecorder.Body.String())
}
var loaded map[string]any
if err := json.Unmarshal(getRecorder.Body.Bytes(), &loaded); err != nil {
t.Fatalf("decode loaded template: %v", err)
}
if loaded["nodeTimeoutSeconds"].(float64) != 12 {
t.Fatalf("expected nodeTimeoutSeconds=12, got %v", loaded["nodeTimeoutSeconds"])
}
schedule := loaded["schedule"].(map[string]any)
if schedule["interval"].(float64) != 90 {
t.Fatalf("expected interval=90, got %v", schedule["interval"])
}
loadedHyperparams := loaded["hyperparams"].([]any)
if len(loadedHyperparams) != 1 || loadedHyperparams[0].(map[string]any)["key"].(string) != "GLOBAL_ENV" {
t.Fatalf("expected template hyperparams to survive load, got %#v", loaded["hyperparams"])
}
updatePayload := []byte(`{
"type":"batch",
"hyperparams":[{"key":"GLOBAL_ENV","value":"template-update"},{"key":"SHARED_MODE","value":"true"}],
"maxConcurrentRuns":3,
"nodeTimeoutSeconds":6,
"runTimeoutSeconds":18,
"maxRetryAttempts":2,
"retryBackoffSeconds":9
}`)
updateRecorder := httptest.NewRecorder()
handler.ServeHTTP(
updateRecorder,
httptest.NewRequest(http.MethodPut, "/api/templates/"+templateID, bytes.NewReader(updatePayload)),
)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("template update status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
var updated map[string]any
if err := json.Unmarshal(updateRecorder.Body.Bytes(), &updated); err != nil {
t.Fatalf("decode updated template: %v", err)
}
if updated["type"].(string) != "batch" {
t.Fatalf("expected batch type after update, got %v", updated["type"])
}
if updated["maxConcurrentRuns"].(float64) != 3 {
t.Fatalf("expected maxConcurrentRuns=3 after update, got %v", updated["maxConcurrentRuns"])
}
if updated["retryBackoffSeconds"].(float64) != 9 {
t.Fatalf("expected retryBackoffSeconds=9 after update, got %v", updated["retryBackoffSeconds"])
}
updatedHyperparams := updated["hyperparams"].([]any)
if len(updatedHyperparams) != 2 || updatedHyperparams[1].(map[string]any)["key"].(string) != "SHARED_MODE" {
t.Fatalf("expected template hyperparams to update, got %#v", updated["hyperparams"])
}
invalidPayload := []byte(`{"maxRetryAttempts":-1}`)
invalidRecorder := httptest.NewRecorder()
handler.ServeHTTP(
invalidRecorder,
httptest.NewRequest(http.MethodPut, "/api/templates/"+templateID, bytes.NewReader(invalidPayload)),
)
if invalidRecorder.Code != http.StatusBadRequest {
t.Fatalf("invalid template update status: %d body=%s", invalidRecorder.Code, invalidRecorder.Body.String())
}
}
func TestWorkflowExecutionConfigValidationAndPersistence(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "执行配置项目",
Description: "workflow execution settings",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
createPayload := []byte(`{
"name":"执行配置工作流",
"description":"workflow",
"type":"batch",
"hyperparams":[{"key":"GLOBAL_ENV","value":"workflow-create"}],
"maxConcurrentRuns":2,
"nodeTimeoutSeconds":30,
"runTimeoutSeconds":120,
"maxRetryAttempts":3,
"retryBackoffSeconds":15,
"nodes":[{"id":"node-source","type":"operator","data":{"label":"真实数据源","category":"IO","description":"source","inputs":[],"outputs":[{"id":"out-1","name":"file","type":"file"}],"hyperparams":[{"key":"SOURCE_TEXT","value":"api-test"}]},"position":{"x":0,"y":0}}],
"edges":[]
}`)
createRecorder := httptest.NewRecorder()
createRequest := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload))
handler.ServeHTTP(createRecorder, createRequest)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("workflow create status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if created.RunTimeoutSeconds != 120 {
t.Fatalf("expected runTimeoutSeconds=120, got %d", created.RunTimeoutSeconds)
}
if created.NodeTimeoutSeconds != 30 {
t.Fatalf("expected nodeTimeoutSeconds=30, got %d", created.NodeTimeoutSeconds)
}
if created.MaxRetryAttempts != 3 {
t.Fatalf("expected maxRetryAttempts=3, got %d", created.MaxRetryAttempts)
}
if created.RetryBackoffSeconds != 15 {
t.Fatalf("expected retryBackoffSeconds=15, got %d", created.RetryBackoffSeconds)
}
if len(created.Hyperparams) != 1 || created.Hyperparams[0].Value != "workflow-create" {
t.Fatalf("expected workflow hyperparams persisted on create, got %#v", created.Hyperparams)
}
updatePayload := []byte(`{
"hyperparams":[{"key":"GLOBAL_ENV","value":"workflow-update"},{"key":"SHARED_MODE","value":"true"}],
"nodeTimeoutSeconds":12,
"runTimeoutSeconds":45,
"maxRetryAttempts":1,
"retryBackoffSeconds":9
}`)
updateRecorder := httptest.NewRecorder()
updateRequest := httptest.NewRequest(http.MethodPut, "/api/workflows/"+created.ID, bytes.NewReader(updatePayload))
handler.ServeHTTP(updateRecorder, updateRequest)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("workflow update status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
var updated domain.WorkflowRecord
if err := json.Unmarshal(updateRecorder.Body.Bytes(), &updated); err != nil {
t.Fatalf("decode updated workflow: %v", err)
}
if updated.RunTimeoutSeconds != 45 {
t.Fatalf("expected updated runTimeoutSeconds=45, got %d", updated.RunTimeoutSeconds)
}
if updated.NodeTimeoutSeconds != 12 {
t.Fatalf("expected updated nodeTimeoutSeconds=12, got %d", updated.NodeTimeoutSeconds)
}
if updated.MaxRetryAttempts != 1 {
t.Fatalf("expected updated maxRetryAttempts=1, got %d", updated.MaxRetryAttempts)
}
if updated.RetryBackoffSeconds != 9 {
t.Fatalf("expected updated retryBackoffSeconds=9, got %d", updated.RetryBackoffSeconds)
}
if len(updated.Hyperparams) != 2 || updated.Hyperparams[1].Key != "SHARED_MODE" {
t.Fatalf("expected workflow hyperparams updated, got %#v", updated.Hyperparams)
}
invalidCreatePayload := []byte(`{
"name":"非法工作流",
"description":"workflow",
"type":"batch",
"nodeTimeoutSeconds":-1,
"runTimeoutSeconds":-1,
"maxRetryAttempts":-2,
"retryBackoffSeconds":-3,
"nodes":[],
"edges":[]
}`)
invalidCreateRecorder := httptest.NewRecorder()
invalidCreateRequest := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(invalidCreatePayload))
handler.ServeHTTP(invalidCreateRecorder, invalidCreateRequest)
if invalidCreateRecorder.Code != http.StatusBadRequest {
t.Fatalf("invalid create status: %d body=%s", invalidCreateRecorder.Code, invalidCreateRecorder.Body.String())
}
invalidUpdatePayload := []byte(`{"nodeTimeoutSeconds":-1,"runTimeoutSeconds":-1,"maxRetryAttempts":-1,"retryBackoffSeconds":-1}`)
invalidUpdateRecorder := httptest.NewRecorder()
invalidUpdateRequest := httptest.NewRequest(http.MethodPut, "/api/workflows/"+created.ID, bytes.NewReader(invalidUpdatePayload))
handler.ServeHTTP(invalidUpdateRecorder, invalidUpdateRequest)
if invalidUpdateRecorder.Code != http.StatusBadRequest {
t.Fatalf("invalid update status: %d body=%s", invalidUpdateRecorder.Code, invalidUpdateRecorder.Body.String())
}
}
func TestCreateAndUpdatePreserveOperatorRunnerImage(t *testing.T) {
t.Setenv("OPERATOR_RUNNER_IMAGE", "ccr-29eug8s3-pub.cnc.bj.baidubce.com/dataflow/droboticflow-operator-runner:20260412151842-amd64")
ctx := context.Background()
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
oldRunnerImage := "ccr-29eug8s3-pub.cnc.bj.baidubce.com/dataflow/droboticflow-operator-runner:20260410181157-amd64"
customImage := "ccr-29eug8s3-pub.cnc.bj.baidubce.com/dataflow/custom-operator:1"
operatorCreatePayload := []byte(`{
"name":"镜像归一化算子",
"type":"builtin",
"category":"IO",
"description":"normalize operator image",
"image":"` + oldRunnerImage + `",
"inputs":[],
"outputs":[{"id":"out-1","name":"output","type":"json"}]
}`)
operatorCreateRecorder := httptest.NewRecorder()
handler.ServeHTTP(operatorCreateRecorder, httptest.NewRequest(http.MethodPost, "/api/operators", bytes.NewReader(operatorCreatePayload)))
if operatorCreateRecorder.Code != http.StatusCreated {
t.Fatalf("operator create status: %d body=%s", operatorCreateRecorder.Code, operatorCreateRecorder.Body.String())
}
var createdOperator domain.OperatorRecord
if err := json.Unmarshal(operatorCreateRecorder.Body.Bytes(), &createdOperator); err != nil {
t.Fatalf("decode created operator: %v", err)
}
if createdOperator.Image != oldRunnerImage {
t.Fatalf("expected created operator image %q, got %q", oldRunnerImage, createdOperator.Image)
}
storedOperator, err := dataStore.GetOperator(ctx, createdOperator.ID)
if err != nil {
t.Fatalf("get stored operator: %v", err)
}
if storedOperator == nil || storedOperator.Image != oldRunnerImage {
t.Fatalf("expected stored operator image %q, got %+v", oldRunnerImage, storedOperator)
}
operatorUpdatePayload := []byte(`{"image":"` + oldRunnerImage + `"}`)
operatorUpdateRecorder := httptest.NewRecorder()
handler.ServeHTTP(operatorUpdateRecorder, httptest.NewRequest(http.MethodPut, "/api/operators/"+createdOperator.ID, bytes.NewReader(operatorUpdatePayload)))
if operatorUpdateRecorder.Code != http.StatusOK {
t.Fatalf("operator update status: %d body=%s", operatorUpdateRecorder.Code, operatorUpdateRecorder.Body.String())
}
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "镜像归一化项目",
Description: "normalize workflow images",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflowCreatePayload := []byte(`{
"name":"镜像归一化工作流",
"description":"normalize workflow node image",
"type":"batch",
"nodes":[
{
"id":"runner-node",
"type":"operator",
"data":{
"label":"Runner Node",
"category":"IO",
"description":"runner node",
"image":"` + oldRunnerImage + `",
"inputs":[],
"outputs":[{"id":"out-1","name":"output","type":"json"}]
},
"position":{"x":0,"y":0}
},
{
"id":"custom-node",
"type":"operator",
"data":{
"label":"Custom Node",
"category":"IO",
"description":"custom node",
"image":"` + customImage + `",
"inputs":[],
"outputs":[{"id":"out-2","name":"output","type":"json"}]
},
"position":{"x":180,"y":0}
}
],
"edges":[]
}`)
workflowCreateRecorder := httptest.NewRecorder()
handler.ServeHTTP(workflowCreateRecorder, httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(workflowCreatePayload)))
if workflowCreateRecorder.Code != http.StatusCreated {
t.Fatalf("workflow create status: %d body=%s", workflowCreateRecorder.Code, workflowCreateRecorder.Body.String())
}
var createdWorkflow domain.WorkflowRecord
if err := json.Unmarshal(workflowCreateRecorder.Body.Bytes(), &createdWorkflow); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if createdWorkflow.Nodes[0].Data.Image != oldRunnerImage {
t.Fatalf("expected created workflow runner image %q, got %q", oldRunnerImage, createdWorkflow.Nodes[0].Data.Image)
}
if createdWorkflow.Nodes[1].Data.Image != customImage {
t.Fatalf("expected custom workflow image to remain %q, got %q", customImage, createdWorkflow.Nodes[1].Data.Image)
}
storedWorkflow, err := dataStore.GetWorkflow(ctx, createdWorkflow.ID)
if err != nil {
t.Fatalf("get stored workflow: %v", err)
}
if storedWorkflow == nil || storedWorkflow.Nodes[0].Data.Image != oldRunnerImage {
t.Fatalf("expected stored workflow runner image %q, got %+v", oldRunnerImage, storedWorkflow)
}
if storedWorkflow.Nodes[1].Data.Image != customImage {
t.Fatalf("expected stored custom workflow image to remain %q, got %q", customImage, storedWorkflow.Nodes[1].Data.Image)
}
workflowUpdatePayload := []byte(`{
"nodes":[
{
"id":"runner-node",
"type":"operator",
"data":{
"label":"Runner Node",
"category":"IO",
"description":"runner node",
"image":"` + oldRunnerImage + `",
"inputs":[],
"outputs":[{"id":"out-1","name":"output","type":"json"}]
},
"position":{"x":0,"y":0}
},
{
"id":"custom-node",
"type":"operator",
"data":{
"label":"Custom Node",
"category":"IO",
"description":"custom node",
"image":"` + customImage + `",
"inputs":[],
"outputs":[{"id":"out-2","name":"output","type":"json"}]
},
"position":{"x":180,"y":0}
}
]
}`)
workflowUpdateRecorder := httptest.NewRecorder()
handler.ServeHTTP(workflowUpdateRecorder, httptest.NewRequest(http.MethodPut, "/api/workflows/"+createdWorkflow.ID, bytes.NewReader(workflowUpdatePayload)))
if workflowUpdateRecorder.Code != http.StatusOK {
t.Fatalf("workflow update status: %d body=%s", workflowUpdateRecorder.Code, workflowUpdateRecorder.Body.String())
}
templateCreatePayload := []byte(`{
"name":"镜像归一化模板",
"description":"normalize template node image",
"type":"batch",
"nodes":[
{
"id":"runner-node",
"type":"operator",
"data":{
"label":"Runner Node",
"category":"IO",
"description":"runner node",
"image":"` + oldRunnerImage + `",
"inputs":[],
"outputs":[{"id":"out-1","name":"output","type":"json"}]
},
"position":{"x":0,"y":0}
},
{
"id":"custom-node",
"type":"operator",
"data":{
"label":"Custom Node",
"category":"IO",
"description":"custom node",
"image":"` + customImage + `",
"inputs":[],
"outputs":[{"id":"out-2","name":"output","type":"json"}]
},
"position":{"x":180,"y":0}
}
],
"edges":[]
}`)
templateCreateRecorder := httptest.NewRecorder()
handler.ServeHTTP(templateCreateRecorder, httptest.NewRequest(http.MethodPost, "/api/templates", bytes.NewReader(templateCreatePayload)))
if templateCreateRecorder.Code != http.StatusCreated {
t.Fatalf("template create status: %d body=%s", templateCreateRecorder.Code, templateCreateRecorder.Body.String())
}
var createdTemplate domain.TemplateRecord
if err := json.Unmarshal(templateCreateRecorder.Body.Bytes(), &createdTemplate); err != nil {
t.Fatalf("decode created template: %v", err)
}
if createdTemplate.Nodes[0].Data.Image != oldRunnerImage {
t.Fatalf("expected created template runner image %q, got %q", oldRunnerImage, createdTemplate.Nodes[0].Data.Image)
}
if createdTemplate.Nodes[1].Data.Image != customImage {
t.Fatalf("expected custom template image to remain %q, got %q", customImage, createdTemplate.Nodes[1].Data.Image)
}
storedTemplate, err := dataStore.GetTemplate(ctx, createdTemplate.ID)
if err != nil {
t.Fatalf("get stored template: %v", err)
}
if storedTemplate == nil || storedTemplate.Nodes[0].Data.Image != oldRunnerImage {
t.Fatalf("expected stored template runner image %q, got %+v", oldRunnerImage, storedTemplate)
}
if storedTemplate.Nodes[1].Data.Image != customImage {
t.Fatalf("expected stored custom template image to remain %q, got %q", customImage, storedTemplate.Nodes[1].Data.Image)
}
templateUpdatePayload := []byte(`{
"nodes":[
{
"id":"runner-node",
"type":"operator",
"data":{
"label":"Runner Node",
"category":"IO",
"description":"runner node",
"image":"` + oldRunnerImage + `",
"inputs":[],
"outputs":[{"id":"out-1","name":"output","type":"json"}]
},
"position":{"x":0,"y":0}
},
{
"id":"custom-node",
"type":"operator",
"data":{
"label":"Custom Node",
"category":"IO",
"description":"custom node",
"image":"` + customImage + `",
"inputs":[],
"outputs":[{"id":"out-2","name":"output","type":"json"}]
},
"position":{"x":180,"y":0}
}
]
}`)
templateUpdateRecorder := httptest.NewRecorder()
handler.ServeHTTP(templateUpdateRecorder, httptest.NewRequest(http.MethodPut, "/api/templates/"+createdTemplate.ID, bytes.NewReader(templateUpdatePayload)))
if templateUpdateRecorder.Code != http.StatusOK {
t.Fatalf("template update status: %d body=%s", templateUpdateRecorder.Code, templateUpdateRecorder.Body.String())
}
}
func TestCompletedWorkflowCannotBeRunAgainManually(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "已完成项目",
Description: "禁止重复运行",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "已完成工作流",
Description: "completed",
Type: domain.WorkflowTypeBatch,
Nodes: []domain.WorkflowNode{
{
ID: "source",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "数据源",
Category: "IO",
Description: "source",
},
Position: domain.Position{X: 0, Y: 0},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
workflow.Status = domain.WorkflowStatusCompleted
if err := dataStore.UpsertWorkflow(ctx, *workflow); err != nil {
t.Fatalf("mark workflow completed: %v", err)
}
handler := NewHandler(dataStore, nil)
runRecorder := httptest.NewRecorder()
runRequest := httptest.NewRequest(
http.MethodPost,
"/api/workflows/"+workflow.ID+"/run",
bytes.NewReader([]byte(`{"trigger":"manual"}`)),
)
handler.ServeHTTP(runRecorder, runRequest)
if runRecorder.Code != http.StatusConflict {
t.Fatalf("expected 409 for completed workflow rerun, got %d body=%s", runRecorder.Code, runRecorder.Body.String())
}
var body map[string]string
if err := json.Unmarshal(runRecorder.Body.Bytes(), &body); err != nil {
t.Fatalf("decode rerun response: %v", err)
}
if body["error"] == "" {
t.Fatalf("expected rerun error message")
}
}
func TestProjectlessScanWorkflowCanRun(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
Name: "无项目扫描工作流",
Description: "projectless scan workflow",
Type: domain.WorkflowTypeBatch,
Kind: domain.WorkflowKindScan,
ScanConfig: &domain.ScanConfig{
DataSource: "BOS",
SourcePath: "bos://datastorage/algo/X-platform-test",
Bucket: "datastorage",
Prefix: "algo/X-platform-test",
Endpoint: "https://bj.bcebos.com",
AccessKeyID: "ak-projectless-1234",
SecretAccessKey: "sk-projectless-5678",
Enabled: false,
},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
handler := NewHandler(dataStore, nil)
runRecorder := httptest.NewRecorder()
runRequest := httptest.NewRequest(
http.MethodPost,
"/api/workflows/"+workflow.ID+"/run",
bytes.NewReader([]byte(`{"trigger":"manual"}`)),
)
handler.ServeHTTP(runRecorder, runRequest)
if runRecorder.Code != http.StatusAccepted {
t.Fatalf("expected 202 for projectless scan workflow run, got %d body=%s", runRecorder.Code, runRecorder.Body.String())
}
var run domain.RunRecord
if err := json.Unmarshal(runRecorder.Body.Bytes(), &run); err != nil {
t.Fatalf("decode run response: %v", err)
}
if run.ProjectID != "" || run.ProjectName != "" {
t.Fatalf("expected blank project scope for projectless run, got %+v", run)
}
}
func TestRunningWorkflowCanBeStoppedGracefully(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "停止项目",
Description: "graceful stop",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "停止工作流",
Description: "stoppable",
Type: domain.WorkflowTypeBatch,
Nodes: []domain.WorkflowNode{
{
ID: "source",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "数据源",
Category: "IO",
Description: "source",
},
Position: domain.Position{X: 0, Y: 0},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
run, err := dataStore.CreateRun(ctx, workflow.ID, domain.RunTriggerManual)
if err != nil {
t.Fatalf("create run: %v", err)
}
run.Status = domain.RunStatusRunning
run.StartedAt = nowISO()
run.UpdatedAt = nowISO()
if err := dataStore.UpsertRun(ctx, *run); err != nil {
t.Fatalf("upsert running run: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
request := httptest.NewRequest(http.MethodPost, "/api/runs/"+run.ID+"/stop", nil)
handler.ServeHTTP(recorder, request)
if recorder.Code != http.StatusOK {
t.Fatalf("expected 200 from graceful stop, got %d body=%s", recorder.Code, recorder.Body.String())
}
stored, err := dataStore.GetRun(ctx, run.ID)
if err != nil {
t.Fatalf("get stored run: %v", err)
}
if stored == nil || stored.Status != domain.RunStatus("stopping") {
t.Fatalf("expected run to enter stopping state, got %#v", stored)
}
}
func TestRunningWorkflowCanBeForceStopped(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
originalFactory := runJobTerminatorFactory
runJobTerminatorFactory = func(namespace string, imagePullSecretName string, workspacePVCName string, workspaceMountPath string) (runJobTerminator, error) {
return testRunJobTerminator{}, nil
}
defer func() {
runJobTerminatorFactory = originalFactory
}()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "强制停止项目",
Description: "force stop",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "强制停止工作流",
Description: "force stoppable",
Type: domain.WorkflowTypeBatch,
Nodes: []domain.WorkflowNode{
{
ID: "source",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "数据源",
Category: "IO",
Description: "source",
},
Position: domain.Position{X: 0, Y: 0},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
run, err := dataStore.CreateRun(ctx, workflow.ID, domain.RunTriggerManual)
if err != nil {
t.Fatalf("create run: %v", err)
}
run.Status = domain.RunStatusRunning
run.StartedAt = nowISO()
run.UpdatedAt = nowISO()
run.K8sRefs = []domain.K8sRef{{NodeID: "source", JobName: "run-source-1", Namespace: "droboticflow"}}
if err := dataStore.UpsertRun(ctx, *run); err != nil {
t.Fatalf("upsert running run: %v", err)
}
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
request := httptest.NewRequest(http.MethodPost, "/api/runs/"+run.ID+"/force-stop", nil)
handler.ServeHTTP(recorder, request)
if recorder.Code != http.StatusOK {
t.Fatalf("expected 200 from force stop, got %d body=%s", recorder.Code, recorder.Body.String())
}
stored, err := dataStore.GetRun(ctx, run.ID)
if err != nil {
t.Fatalf("get stored run: %v", err)
}
if stored == nil || stored.Status != domain.RunStatusCancelled {
t.Fatalf("expected run to be cancelled, got %#v", stored)
}
if stored.EndedAt == "" {
t.Fatalf("expected cancelled run to be ended")
}
}
type testRunJobTerminator struct{}
func (testRunJobTerminator) TerminateRun(context.Context, string, string) error { return nil }
func (testRunJobTerminator) TerminateJob(context.Context, string, string) error { return nil }
func TestProjectWorkflowAPISupportsNativeScanWorkflows(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
for _, name := range []string{"BOS 增量扫描", "X 平台数据集索引", "采集目录校验"} {
if _, err := dataStore.CreateOperator(ctx, domain.CreateOperatorInput{
Name: name,
Type: "builtin",
Category: "IO",
Description: name,
Inputs: []domain.PortDefinition{{ID: "in-1", Name: "input", Type: domain.PortTypeJSON}},
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "output", Type: domain.PortTypeJSON}},
}); err != nil {
t.Fatalf("create operator %s: %v", name, err)
}
}
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "扫描项目",
Description: "native workflow scan api",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"X-platform BOS 扫描",
"description":"扫描 workflow 原生创建",
"type":"batch",
"kind":"scan",
"schedule":{"interval":900},
"scanConfig":{
"dataSource":"BOS",
"bucket":"datastorage",
"prefix":"algo/X-platform-test/",
"endpoint":"https://bj.bcebos.com",
"accessKeyId":"ak-native-1234",
"secretAccessKey":"sk-native-5678",
"scanMode":"INCREMENTAL",
"incrementalUnit":"DIRECTORY",
"directoryDepth":2,
"pattern":"*.mp4",
"enabled":true
},
"nodes":[],
"edges":[]
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("create scan workflow status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if created.Kind != domain.WorkflowKindScan {
t.Fatalf("expected scan workflow kind, got %s", created.Kind)
}
if created.Type != domain.WorkflowTypeStreaming {
t.Fatalf("expected streaming scan workflow, got %s", created.Type)
}
if created.ScanConfig == nil {
t.Fatalf("expected scan config in response")
}
if created.ScanConfig.AccessKeyID != "ak-native-1234" || created.ScanConfig.SecretAccessKey != "sk-native-5678" {
t.Fatalf("expected raw secrets in response: %+v", created.ScanConfig)
}
if !created.ScanConfig.HasAccessKeyID || !created.ScanConfig.HasSecretAccessKey {
t.Fatalf("expected secret presence flags in response: %+v", created.ScanConfig)
}
if created.ScanConfig.AccessKeyPreview == "" || created.ScanConfig.SecretAccessKeyPreview == "" {
t.Fatalf("expected secret previews in response: %+v", created.ScanConfig)
}
if created.ScanConfig.ScanMode != "INCREMENTAL" {
t.Fatalf("expected incremental scan mode, got %s", created.ScanConfig.ScanMode)
}
if created.ScanConfig.IncrementalUnit != "DIRECTORY" || created.ScanConfig.DirectoryDepth != 2 {
t.Fatalf("expected directory incremental config, got %+v", created.ScanConfig)
}
if len(created.Nodes) != 3 || len(created.Edges) != 2 {
t.Fatalf("expected default scan graph scaffold, got %d nodes and %d edges", len(created.Nodes), len(created.Edges))
}
stored, err := dataStore.GetWorkflow(ctx, created.ID)
if err != nil {
t.Fatalf("get stored workflow: %v", err)
}
if stored == nil || stored.ScanConfig == nil {
t.Fatalf("expected stored workflow scan config")
}
if stored.ScanConfig.AccessKeyID != "ak-native-1234" || stored.ScanConfig.SecretAccessKey != "sk-native-5678" {
t.Fatalf("expected secrets preserved in store: %+v", stored.ScanConfig)
}
if stored.ScanConfig.IncrementalUnit != "DIRECTORY" || stored.ScanConfig.DirectoryDepth != 2 {
t.Fatalf("expected stored directory incremental config, got %+v", stored.ScanConfig)
}
if stored.Schedule == nil || stored.Schedule.Interval != 900 {
t.Fatalf("expected schedule interval persisted, got %+v", stored.Schedule)
}
if stored.Schedule.SourcePath != "bos://datastorage/algo/X-platform-test" {
t.Fatalf("unexpected stored source path: %+v", stored.Schedule)
}
updatePayload := []byte(`{
"schedule":{"interval":0},
"scanConfig":{
"dataSource":"BOS",
"bucket":"datastorage",
"prefix":"algo/X-platform-test",
"endpoint":"https://bj.bcebos.com",
"accessKeyId":"",
"secretAccessKey":"",
"scanMode":"FULL",
"incrementalUnit":"OBJECT",
"directoryDepth":1,
"pattern":"*.json",
"enabled":false
}
}`)
updateRecorder := httptest.NewRecorder()
handler.ServeHTTP(
updateRecorder,
httptest.NewRequest(http.MethodPut, "/api/workflows/"+created.ID, bytes.NewReader(updatePayload)),
)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("update scan workflow status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
updated, err := dataStore.GetWorkflow(ctx, created.ID)
if err != nil {
t.Fatalf("get updated workflow: %v", err)
}
if updated == nil || updated.ScanConfig == nil {
t.Fatalf("expected updated scan config")
}
if updated.Type != domain.WorkflowTypeBatch {
t.Fatalf("expected batch after disabling scan schedule, got %s", updated.Type)
}
if updated.ScanConfig.AccessKeyID != "ak-native-1234" || updated.ScanConfig.SecretAccessKey != "sk-native-5678" {
t.Fatalf("expected secrets preserved on generic workflow update: %+v", updated.ScanConfig)
}
if updated.ScanConfig.ScanMode != "FULL" {
t.Fatalf("expected full scan mode after update, got %s", updated.ScanConfig.ScanMode)
}
if updated.ScanConfig.IncrementalUnit != "OBJECT" || updated.ScanConfig.DirectoryDepth != 1 {
t.Fatalf("expected updated incremental config, got %+v", updated.ScanConfig)
}
if updated.Schedule == nil || updated.Schedule.Interval != 0 {
t.Fatalf("expected schedule interval reset to 0, got %+v", updated.Schedule)
}
}
func TestProjectWorkflowCreateInfersScanConfigFromIncrementalSourceNode(t *testing.T) {
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(context.Background(), domain.CreateProjectInput{
Name: "增量项目",
Description: "generic incremental dag",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"增量全链路",
"description":"generic incremental dag",
"type":"streaming",
"schedule":{"interval":45},
"nodes":[
{
"id":"source",
"type":"operator",
"data":{
"label":"BOS 增量扫描",
"category":"IO",
"description":"source",
"inputs":[],
"outputs":[{"id":"out-1","name":"manifest","type":"json"}],
"bucket":"wjzh-data-migration",
"prefix":"wjzh-0330-Data-migration",
"pattern":"*.mp4",
"hyperparams":[
{"key":"DATA_SOURCE","value":"BOS"},
{"key":"SOURCE_PATH","value":"bos://wjzh-data-migration/wjzh-0330-Data-migration"},
{"key":"BOS_ENDPOINT","value":"https://bj.bcebos.com"},
{"key":"BOS_ACCESS_KEY_ID","value":"ak-node-123"},
{"key":"BOS_SECRET_ACCESS_KEY","value":"sk-node-456"},
{"key":"SCAN_MODE","value":"INCREMENTAL"}
]
},
"position":{"x":0,"y":0}
},
{
"id":"quality",
"type":"operator",
"data":{
"label":"视频质检",
"category":"VIDEO",
"description":"quality",
"inputs":[{"id":"in-1","name":"input","type":"json"}],
"outputs":[{"id":"out-1","name":"quality","type":"json"}]
},
"position":{"x":200,"y":0}
}
],
"edges":[
{"id":"source-quality","source":"source","sourceHandle":"out-1","target":"quality","targetHandle":"in-1"}
]
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload)),
)
if recorder.Code != http.StatusCreated {
t.Fatalf("create incremental workflow status: %d body=%s", recorder.Code, recorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(recorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if created.Kind != domain.WorkflowKindScan {
t.Fatalf("expected scan kind, got %s", created.Kind)
}
if created.Type != domain.WorkflowTypeStreaming {
t.Fatalf("expected streaming workflow, got %s", created.Type)
}
if created.ScanConfig == nil {
t.Fatalf("expected inferred scan config")
}
if created.ScanConfig.SourcePath != "bos://wjzh-data-migration/wjzh-0330-Data-migration" {
t.Fatalf("unexpected inferred source path: %+v", created.ScanConfig)
}
if created.ScanConfig.Bucket != "wjzh-data-migration" || created.ScanConfig.Prefix != "wjzh-0330-Data-migration" {
t.Fatalf("unexpected inferred bucket/prefix: %+v", created.ScanConfig)
}
if created.ScanConfig.AccessKeyID != "ak-node-123" || created.ScanConfig.SecretAccessKey != "sk-node-456" {
t.Fatalf("expected inferred raw secrets, got %+v", created.ScanConfig)
}
if created.ScanConfig.ScanMode != "INCREMENTAL" {
t.Fatalf("expected inferred incremental scan mode, got %+v", created.ScanConfig)
}
if created.MaxConcurrentRuns != 1 {
t.Fatalf("expected inferred scan workflow maxConcurrentRuns=1, got %d", created.MaxConcurrentRuns)
}
if created.Schedule == nil || created.Schedule.Interval != 45 || created.Schedule.SourcePath != "bos://wjzh-data-migration/wjzh-0330-Data-migration" {
t.Fatalf("unexpected inferred schedule: %+v", created.Schedule)
}
if len(created.Nodes) != 2 || len(created.Edges) != 1 {
t.Fatalf("expected original graph to be preserved, got %d nodes %d edges", len(created.Nodes), len(created.Edges))
}
}
func TestProjectWorkflowCreatePreservesBOSSourcePathWhenUsingConnectionReference(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "连接引用扫描项目",
Description: "connection + sourcePath",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
connection, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
Name: "WJZH Connection",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
Bucket: "wjzh-data-migration",
AccessKeyID: "ak-conn",
SecretAccessKey: "sk-conn",
})
if err != nil {
t.Fatalf("create storage connection: %v", err)
}
handler := NewHandler(dataStore, nil)
createPayload := []byte(fmt.Sprintf(`{
"name":"连接引用增量烟测",
"description":"scan config should keep explicit sourcePath",
"type":"batch",
"nodes":[
{
"id":"source",
"type":"operator",
"data":{
"label":"BOS 增量扫描",
"category":"IO",
"description":"source",
"inputs":[],
"outputs":[{"id":"out-1","name":"manifest","type":"json"}],
"connectionId":"%s",
"hyperparams":[
{"key":"DATA_SOURCE","value":"BOS"},
{"key":"SOURCE_PATH","value":"bos://wjzh-data-migration/wjzh-0330-Data-migration"},
{"key":"SCAN_MODE","value":"FULL"}
]
},
"position":{"x":0,"y":0}
}
],
"edges":[]
}`, connection.ID))
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload)),
)
if recorder.Code != http.StatusCreated {
t.Fatalf("create workflow status: %d body=%s", recorder.Code, recorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(recorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if created.ScanConfig == nil {
t.Fatalf("expected scan config")
}
if created.ScanConfig.ConnectionID != connection.ID {
t.Fatalf("expected connection reference to be preserved, got %+v", created.ScanConfig)
}
if created.ScanConfig.SourcePath != "bos://wjzh-data-migration/wjzh-0330-Data-migration" {
t.Fatalf("expected explicit bos sourcePath to be preserved, got %+v", created.ScanConfig)
}
runRecorder := httptest.NewRecorder()
handler.ServeHTTP(
runRecorder,
httptest.NewRequest(http.MethodPost, "/api/workflows/"+created.ID+"/run", bytes.NewReader([]byte(`{"trigger":"manual"}`))),
)
if runRecorder.Code != http.StatusCreated && runRecorder.Code != http.StatusAccepted {
t.Fatalf("expected connectionId + sourcePath workflow to run, got %d body=%s", runRecorder.Code, runRecorder.Body.String())
}
}
func TestWorkflowUpdateInfersScanConfigFromIncrementalSourceNode(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "增量更新项目",
Description: "generic incremental dag",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "待升级增量工作流",
Description: "incremental update",
Type: domain.WorkflowTypeBatch,
Schedule: &domain.WorkflowSchedule{Interval: 0},
Nodes: []domain.WorkflowNode{
{
ID: "source",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "BOS 增量扫描",
Category: "IO",
Description: "source",
Bucket: "wjzh-data-migration",
Prefix: "wjzh-0330-Data-migration",
Pattern: "*.json",
Hyperparams: []domain.HyperParam{
{Key: "DATA_SOURCE", Value: "BOS"},
{Key: "SOURCE_PATH", Value: "bos://wjzh-data-migration/wjzh-0330-Data-migration"},
{Key: "BOS_ENDPOINT", Value: "https://bj.bcebos.com"},
{Key: "BOS_ACCESS_KEY_ID", Value: "ak-update-123"},
{Key: "BOS_SECRET_ACCESS_KEY", Value: "sk-update-456"},
{Key: "SCAN_MODE", Value: "FULL"},
},
},
Position: domain.Position{X: 0, Y: 0},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
handler := NewHandler(dataStore, nil)
updatePayload := []byte(`{
"type":"streaming",
"schedule":{"interval":75}
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPut, "/api/workflows/"+workflow.ID, bytes.NewReader(updatePayload)),
)
if recorder.Code != http.StatusOK {
t.Fatalf("update incremental workflow status: %d body=%s", recorder.Code, recorder.Body.String())
}
updated, err := dataStore.GetWorkflow(ctx, workflow.ID)
if err != nil {
t.Fatalf("get updated workflow: %v", err)
}
if updated == nil || updated.ScanConfig == nil {
t.Fatalf("expected inferred scan config after update")
}
if updated.Kind != domain.WorkflowKindScan {
t.Fatalf("expected scan kind after update, got %s", updated.Kind)
}
if updated.Type != domain.WorkflowTypeStreaming {
t.Fatalf("expected streaming type after update, got %s", updated.Type)
}
if updated.ScanConfig.AccessKeyID != "ak-update-123" || updated.ScanConfig.SecretAccessKey != "sk-update-456" {
t.Fatalf("expected secrets derived from node hyperparams, got %+v", updated.ScanConfig)
}
if updated.ScanConfig.ScanMode != "FULL" {
t.Fatalf("expected scan mode derived from node hyperparams, got %+v", updated.ScanConfig)
}
if updated.MaxConcurrentRuns != 1 {
t.Fatalf("expected inferred scan workflow maxConcurrentRuns=1 after update, got %d", updated.MaxConcurrentRuns)
}
if updated.Schedule == nil || updated.Schedule.Interval != 75 || updated.Schedule.SourcePath != "bos://wjzh-data-migration/wjzh-0330-Data-migration" {
t.Fatalf("unexpected updated schedule: %+v", updated.Schedule)
}
}
func TestTemplateCreateInfersScanConfigFromIncrementalSourceNode(t *testing.T) {
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"增量模板",
"description":"template incremental dag",
"type":"streaming",
"schedule":{"interval":30},
"nodes":[
{
"id":"source",
"type":"operator",
"data":{
"label":"BOS 增量扫描",
"category":"IO",
"description":"source",
"inputs":[],
"outputs":[{"id":"out-1","name":"manifest","type":"json"}],
"bucket":"wjzh-data-migration",
"prefix":"wjzh-0330-Data-migration",
"pattern":"*.mp4",
"hyperparams":[
{"key":"DATA_SOURCE","value":"BOS"},
{"key":"SOURCE_PATH","value":"bos://wjzh-data-migration/wjzh-0330-Data-migration"},
{"key":"BOS_ENDPOINT","value":"https://bj.bcebos.com"},
{"key":"BOS_ACCESS_KEY_ID","value":"ak-template-123"},
{"key":"BOS_SECRET_ACCESS_KEY","value":"sk-template-456"},
{"key":"SCAN_MODE","value":"INCREMENTAL"}
]
},
"position":{"x":0,"y":0}
}
],
"edges":[]
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/templates", bytes.NewReader(createPayload)),
)
if recorder.Code != http.StatusCreated {
t.Fatalf("create incremental template status: %d body=%s", recorder.Code, recorder.Body.String())
}
var created domain.TemplateRecord
if err := json.Unmarshal(recorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created template: %v", err)
}
if created.Kind != domain.WorkflowKindScan {
t.Fatalf("expected scan template kind, got %s", created.Kind)
}
if created.Type != domain.WorkflowTypeStreaming {
t.Fatalf("expected streaming template type, got %s", created.Type)
}
if created.ScanConfig == nil {
t.Fatalf("expected inferred template scan config")
}
if created.ScanConfig.AccessKeyID != "ak-template-123" || created.ScanConfig.SecretAccessKey != "sk-template-456" {
t.Fatalf("expected inferred template secrets, got %+v", created.ScanConfig)
}
if created.MaxConcurrentRuns != 1 {
t.Fatalf("expected inferred scan template maxConcurrentRuns=1, got %d", created.MaxConcurrentRuns)
}
if created.Schedule == nil || created.Schedule.Interval != 30 || created.Schedule.SourcePath != "bos://wjzh-data-migration/wjzh-0330-Data-migration" {
t.Fatalf("unexpected template schedule: %+v", created.Schedule)
}
}
func TestTemplateUpdateInfersScanConfigFromIncrementalSourceNode(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
template, err := dataStore.CreateTemplate(ctx, domain.CreateTemplateInput{
Name: "待升级增量模板",
Description: "incremental template update",
Type: domain.WorkflowTypeBatch,
Schedule: &domain.WorkflowSchedule{Interval: 0},
Nodes: []domain.WorkflowNode{
{
ID: "source",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "BOS 增量扫描",
Category: "IO",
Description: "source",
Bucket: "wjzh-data-migration",
Prefix: "wjzh-0330-Data-migration",
Pattern: "*.json",
Hyperparams: []domain.HyperParam{
{Key: "DATA_SOURCE", Value: "BOS"},
{Key: "SOURCE_PATH", Value: "bos://wjzh-data-migration/wjzh-0330-Data-migration"},
{Key: "BOS_ENDPOINT", Value: "https://bj.bcebos.com"},
{Key: "BOS_ACCESS_KEY_ID", Value: "ak-template-update-123"},
{Key: "BOS_SECRET_ACCESS_KEY", Value: "sk-template-update-456"},
{Key: "SCAN_MODE", Value: "INCREMENTAL"},
},
},
Position: domain.Position{X: 0, Y: 0},
},
},
Edges: []domain.WorkflowEdge{},
})
if err != nil {
t.Fatalf("create template: %v", err)
}
handler := NewHandler(dataStore, nil)
updatePayload := []byte(`{
"type":"streaming",
"schedule":{"interval":90}
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPut, "/api/templates/"+template.ID, bytes.NewReader(updatePayload)),
)
if recorder.Code != http.StatusOK {
t.Fatalf("update incremental template status: %d body=%s", recorder.Code, recorder.Body.String())
}
updated, err := dataStore.GetTemplate(ctx, template.ID)
if err != nil {
t.Fatalf("get updated template: %v", err)
}
if updated == nil || updated.ScanConfig == nil {
t.Fatalf("expected inferred template scan config after update")
}
if updated.Kind != domain.WorkflowKindScan {
t.Fatalf("expected scan template kind after update, got %s", updated.Kind)
}
if updated.Type != domain.WorkflowTypeStreaming {
t.Fatalf("expected streaming template type after update, got %s", updated.Type)
}
if updated.ScanConfig.AccessKeyID != "ak-template-update-123" || updated.ScanConfig.SecretAccessKey != "sk-template-update-456" {
t.Fatalf("expected template secrets derived from node hyperparams, got %+v", updated.ScanConfig)
}
if updated.ScanConfig.ScanMode != "INCREMENTAL" {
t.Fatalf("expected template scan mode derived from node hyperparams, got %+v", updated.ScanConfig)
}
if updated.MaxConcurrentRuns != 1 {
t.Fatalf("expected inferred scan template maxConcurrentRuns=1 after update, got %d", updated.MaxConcurrentRuns)
}
if updated.Schedule == nil || updated.Schedule.Interval != 90 || updated.Schedule.SourcePath != "bos://wjzh-data-migration/wjzh-0330-Data-migration" {
t.Fatalf("unexpected updated template schedule: %+v", updated.Schedule)
}
}
func TestProjectWorkflowCreatePersistsEveryHoursSchedule(t *testing.T) {
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(context.Background(), domain.CreateProjectInput{
Name: "小时调度项目",
Description: "hourly schedule",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
payload := []byte(`{
"name":"小时调度工作流",
"description":"hourly schedule",
"type":"streaming",
"schedule":{
"mode":"every_hours",
"intervalHours":4
},
"nodes":[],
"edges":[]
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(payload)),
)
if recorder.Code != http.StatusCreated {
t.Fatalf("create hourly workflow status: %d body=%s", recorder.Code, recorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(recorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if created.Schedule == nil {
t.Fatalf("expected schedule persisted")
}
if created.Schedule.Mode != domain.WorkflowScheduleModeEveryHours {
t.Fatalf("expected every_hours mode, got %+v", created.Schedule)
}
if created.Schedule.IntervalHours != 4 {
t.Fatalf("expected intervalHours=4, got %+v", created.Schedule)
}
if strings.TrimSpace(created.Schedule.AnchorAt) == "" {
t.Fatalf("expected anchorAt populated, got %+v", created.Schedule)
}
}
func TestTemplateCreatePersistsEveryDaysScheduleDefaultsTimezone(t *testing.T) {
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
payload := []byte(`{
"name":"按天模板",
"description":"daily schedule",
"type":"streaming",
"schedule":{
"mode":"every_days_at_time",
"dayInterval":2,
"timeOfDay":"18:30"
},
"nodes":[],
"edges":[]
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/templates", bytes.NewReader(payload)),
)
if recorder.Code != http.StatusCreated {
t.Fatalf("create daily template status: %d body=%s", recorder.Code, recorder.Body.String())
}
var created domain.TemplateRecord
if err := json.Unmarshal(recorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created template: %v", err)
}
if created.Schedule == nil {
t.Fatalf("expected schedule persisted")
}
if created.Schedule.Mode != domain.WorkflowScheduleModeEveryDaysAtTime {
t.Fatalf("expected every_days_at_time mode, got %+v", created.Schedule)
}
if created.Schedule.DayInterval != 2 || created.Schedule.TimeOfDay != "18:30" {
t.Fatalf("unexpected daily schedule payload: %+v", created.Schedule)
}
if created.Schedule.Timezone != domain.DefaultWorkflowScheduleTimezone {
t.Fatalf("expected default timezone %q, got %+v", domain.DefaultWorkflowScheduleTimezone, created.Schedule)
}
if strings.TrimSpace(created.Schedule.AnchorAt) == "" {
t.Fatalf("expected anchorAt populated, got %+v", created.Schedule)
}
}
func TestProjectWorkflowCreateRejectsInvalidEveryDaysSchedule(t *testing.T) {
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(context.Background(), domain.CreateProjectInput{
Name: "非法调度项目",
Description: "invalid schedule",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
payload := []byte(`{
"name":"非法按天工作流",
"description":"invalid daily schedule",
"type":"streaming",
"schedule":{
"mode":"every_days_at_time",
"dayInterval":1,
"timeOfDay":"25:61"
},
"nodes":[],
"edges":[]
}`)
recorder := httptest.NewRecorder()
handler.ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(payload)),
)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("expected invalid daily schedule rejected, got %d body=%s", recorder.Code, recorder.Body.String())
}
if !strings.Contains(recorder.Body.String(), "schedule.timeOfDay") {
t.Fatalf("expected timeOfDay validation issue, body=%s", recorder.Body.String())
}
}
func TestStorageConnectionsAPIStoresSecretsMasked(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"BOS 主连接",
"description":"扫描用 BOS 连接",
"provider":"BOS",
"endpoint":"https://bj.bcebos.com",
"bucket":"datastorage",
"accessKeyId":"ak-connection-1234",
"secretAccessKey":"sk-connection-5678"
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/storage/connections", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("create storage connection status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created map[string]any
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created connection: %v", err)
}
if _, ok := created["accessKeyId"]; ok {
t.Fatalf("expected masked accessKeyId to be omitted: %#v", created)
}
if _, ok := created["secretAccessKey"]; ok {
t.Fatalf("expected masked secretAccessKey to be omitted: %#v", created)
}
if created["hasAccessKeyId"] != true || created["hasSecretAccessKey"] != true {
t.Fatalf("expected secret presence flags in response: %#v", created)
}
if created["accessKeyPreview"] == "" || created["secretAccessKeyPreview"] == "" {
t.Fatalf("expected secret previews in response: %#v", created)
}
stored, err := dataStore.GetStorageConnection(ctx, created["id"].(string))
if err != nil {
t.Fatalf("get stored storage connection: %v", err)
}
if stored == nil {
t.Fatalf("expected stored connection")
}
if stored.Bucket != "datastorage" {
t.Fatalf("expected bucket preserved in store: %#v", stored)
}
if stored.AccessKeyID != "ak-connection-1234" || stored.SecretAccessKey != "sk-connection-5678" {
t.Fatalf("expected real secrets preserved in store: %#v", stored)
}
updatePayload := []byte(`{
"description":"更新后的连接描述",
"endpoint":"https://gz.bcebos.com",
"bucket":"archive",
"accessKeyId":"",
"secretAccessKey":""
}`)
updateRecorder := httptest.NewRecorder()
handler.ServeHTTP(
updateRecorder,
httptest.NewRequest(http.MethodPut, "/api/storage/connections/"+created["id"].(string), bytes.NewReader(updatePayload)),
)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("update storage connection status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
updated, err := dataStore.GetStorageConnection(ctx, created["id"].(string))
if err != nil {
t.Fatalf("get updated storage connection: %v", err)
}
if updated == nil {
t.Fatalf("expected updated connection")
}
if updated.Description != "更新后的连接描述" || updated.Endpoint != "https://gz.bcebos.com" || updated.Bucket != "archive" {
t.Fatalf("unexpected updated connection: %#v", updated)
}
if updated.AccessKeyID != "ak-connection-1234" || updated.SecretAccessKey != "sk-connection-5678" {
t.Fatalf("expected blank update payload to preserve secrets: %#v", updated)
}
listRecorder := httptest.NewRecorder()
handler.ServeHTTP(listRecorder, httptest.NewRequest(http.MethodGet, "/api/storage/connections", nil))
if listRecorder.Code != http.StatusOK {
t.Fatalf("list storage connections status: %d body=%s", listRecorder.Code, listRecorder.Body.String())
}
var listBody struct {
Items []map[string]any `json:"items"`
}
if err := json.Unmarshal(listRecorder.Body.Bytes(), &listBody); err != nil {
t.Fatalf("decode storage connection list: %v", err)
}
if len(listBody.Items) != 1 {
t.Fatalf("expected 1 storage connection, got %d", len(listBody.Items))
}
}
func TestMongoConnectionsAPIStoresSecretsMasked(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"业务 MongoDB",
"description":"测试业务库",
"uri":"mongodb://business-user:business-pass@business.example:27017",
"database":"business_data"
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/mongo/connections", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("create mongo connection status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created map[string]any
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created mongo connection: %v", err)
}
if _, ok := created["uri"]; ok {
t.Fatalf("expected masked uri to be omitted: %#v", created)
}
if created["hasUri"] != true || created["uriPreview"] == "" {
t.Fatalf("expected uri presence metadata: %#v", created)
}
stored, err := dataStore.GetMongoConnection(ctx, created["id"].(string))
if err != nil {
t.Fatalf("get stored mongo connection: %v", err)
}
if stored == nil {
t.Fatalf("expected stored mongo connection")
}
if stored.URI != "mongodb://business-user:business-pass@business.example:27017" {
t.Fatalf("expected real uri preserved in store: %#v", stored)
}
updatePayload := []byte(`{
"description":"更新后的测试业务库",
"uri":"",
"database":"business_data_v2"
}`)
updateRecorder := httptest.NewRecorder()
handler.ServeHTTP(
updateRecorder,
httptest.NewRequest(http.MethodPut, "/api/mongo/connections/"+created["id"].(string), bytes.NewReader(updatePayload)),
)
if updateRecorder.Code != http.StatusOK {
t.Fatalf("update mongo connection status: %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
updated, err := dataStore.GetMongoConnection(ctx, created["id"].(string))
if err != nil {
t.Fatalf("get updated mongo connection: %v", err)
}
if updated == nil {
t.Fatalf("expected updated mongo connection")
}
if updated.Description != "更新后的测试业务库" || updated.Database != "business_data_v2" {
t.Fatalf("unexpected updated mongo connection: %#v", updated)
}
if updated.URI != "mongodb://business-user:business-pass@business.example:27017" {
t.Fatalf("expected blank update payload to preserve uri: %#v", updated)
}
listRecorder := httptest.NewRecorder()
handler.ServeHTTP(listRecorder, httptest.NewRequest(http.MethodGet, "/api/mongo/connections", nil))
if listRecorder.Code != http.StatusOK {
t.Fatalf("list mongo connections status: %d body=%s", listRecorder.Code, listRecorder.Body.String())
}
var listBody struct {
Items []map[string]any `json:"items"`
}
if err := json.Unmarshal(listRecorder.Body.Bytes(), &listBody); err != nil {
t.Fatalf("decode mongo connection list: %v", err)
}
if len(listBody.Items) != 1 {
t.Fatalf("expected 1 mongo connection, got %d", len(listBody.Items))
}
}
func TestStorageBrowserSupportsConnectionID(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
Name: "BOS 主连接",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
AccessKeyID: "ak-browser-1234",
SecretAccessKey: "sk-browser-5678",
})
if err != nil {
t.Fatalf("create storage connection: %v", err)
}
originalBucketsResolver := storageConnectionBucketsResolver
originalObjectsResolver := storageConnectionObjectsResolver
storageConnectionBucketsResolver = func(ctx context.Context, item *domain.StorageConnectionRecord) ([]string, error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected storage connection for buckets: %#v", item)
}
return []string{"datastorage", "incoming"}, nil
}
storageConnectionObjectsResolver = func(ctx context.Context, item *domain.StorageConnectionRecord, bucket string, prefix string) ([]string, error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected storage connection for objects: %#v", item)
}
if bucket != "datastorage" || prefix != "algo/X-platform-test" {
t.Fatalf("unexpected bucket/prefix: %s %s", bucket, prefix)
}
return []string{"algo/X-platform-test/BJ_001/", "algo/X-platform-test/meta.json"}, nil
}
t.Cleanup(func() {
storageConnectionBucketsResolver = originalBucketsResolver
storageConnectionObjectsResolver = originalObjectsResolver
})
handler := NewHandler(dataStore, nil)
bucketsRecorder := httptest.NewRecorder()
handler.ServeHTTP(
bucketsRecorder,
httptest.NewRequest(http.MethodGet, "/api/storage/buckets?connectionId="+connection.ID, nil),
)
if bucketsRecorder.Code != http.StatusOK {
t.Fatalf("connection buckets status: %d body=%s", bucketsRecorder.Code, bucketsRecorder.Body.String())
}
objectsRecorder := httptest.NewRecorder()
handler.ServeHTTP(
objectsRecorder,
httptest.NewRequest(http.MethodGet, "/api/storage/objects?connectionId="+connection.ID+"&bucket=datastorage&prefix=algo/X-platform-test", nil),
)
if objectsRecorder.Code != http.StatusOK {
t.Fatalf("connection objects status: %d body=%s", objectsRecorder.Code, objectsRecorder.Body.String())
}
}
type fakeObjectStorageBrowser struct {
buckets map[string]struct{}
objects map[string]domain.ObjectStorageObjectSummary
content map[string][]byte
readErr map[string]error
readCalls map[string]int
readPreviewCalls map[string]int
lastPreviewMaxLen map[string]int64
}
func newFakeObjectStorageBrowser() *fakeObjectStorageBrowser {
return &fakeObjectStorageBrowser{
buckets: map[string]struct{}{
"datastorage": {},
},
objects: map[string]domain.ObjectStorageObjectSummary{
"datastorage|algo/demo.json": {
Bucket: "datastorage",
Key: "algo/demo.json",
Name: "demo.json",
Kind: "json",
SizeBytes: 13,
ContentType: "application/json",
},
},
content: map[string][]byte{
"datastorage|algo/demo.json": []byte(`{"demo":true}`),
},
readErr: map[string]error{},
readCalls: map[string]int{},
readPreviewCalls: map[string]int{},
lastPreviewMaxLen: map[string]int64{},
}
}
func (browser *fakeObjectStorageBrowser) ListBuckets(context.Context) ([]domain.ObjectStorageBucketSummary, error) {
items := make([]domain.ObjectStorageBucketSummary, 0, len(browser.buckets))
for bucket := range browser.buckets {
items = append(items, domain.ObjectStorageBucketSummary{Name: bucket})
}
sort.Slice(items, func(left int, right int) bool { return items[left].Name < items[right].Name })
return items, nil
}
func (browser *fakeObjectStorageBrowser) ListObjects(_ context.Context, bucket string, prefix string) ([]domain.ObjectStorageObjectSummary, error) {
items := make([]domain.ObjectStorageObjectSummary, 0)
normalizedPrefix := strings.Trim(strings.TrimSpace(prefix), "/")
for _, item := range browser.objects {
if item.Bucket != bucket {
continue
}
if normalizedPrefix != "" && !strings.HasPrefix(item.Key, normalizedPrefix) {
continue
}
items = append(items, item)
}
sort.Slice(items, func(left int, right int) bool { return items[left].Key < items[right].Key })
return items, nil
}
func (browser *fakeObjectStorageBrowser) CreateBucket(_ context.Context, bucket string) (domain.ObjectStorageBucketSummary, error) {
browser.buckets[bucket] = struct{}{}
return domain.ObjectStorageBucketSummary{Name: bucket}, nil
}
func (browser *fakeObjectStorageBrowser) DeleteBucket(_ context.Context, bucket string) error {
delete(browser.buckets, bucket)
return nil
}
func (browser *fakeObjectStorageBrowser) PutObject(_ context.Context, bucket string, key string, payload []byte, contentType string) (domain.ObjectStorageObjectSummary, error) {
browser.buckets[bucket] = struct{}{}
item := domain.ObjectStorageObjectSummary{
Bucket: bucket,
Key: key,
Name: filepath.Base(key),
Kind: "file",
SizeBytes: int64(len(payload)),
ContentType: contentType,
}
if strings.HasSuffix(strings.ToLower(key), ".json") {
item.Kind = "json"
}
browser.objects[bucket+"|"+key] = item
browser.content[bucket+"|"+key] = append([]byte(nil), payload...)
return item, nil
}
func (browser *fakeObjectStorageBrowser) RenameObject(_ context.Context, bucket string, key string, newKey string) (domain.ObjectStorageObjectSummary, error) {
item := browser.objects[bucket+"|"+key]
delete(browser.objects, bucket+"|"+key)
item.Key = newKey
item.Name = filepath.Base(newKey)
browser.objects[bucket+"|"+newKey] = item
browser.content[bucket+"|"+newKey] = browser.content[bucket+"|"+key]
delete(browser.content, bucket+"|"+key)
return item, nil
}
func (browser *fakeObjectStorageBrowser) DeleteObject(_ context.Context, bucket string, key string) error {
delete(browser.objects, bucket+"|"+key)
delete(browser.content, bucket+"|"+key)
return nil
}
func (browser *fakeObjectStorageBrowser) DeletePrefix(_ context.Context, bucket string, prefix string) error {
normalized := strings.Trim(strings.TrimSpace(prefix), "/")
for objectKey := range browser.objects {
if !strings.HasPrefix(objectKey, bucket+"|") {
continue
}
key := strings.TrimPrefix(objectKey, bucket+"|")
if key == normalized || strings.HasPrefix(key, normalized+"/") {
delete(browser.objects, objectKey)
delete(browser.content, objectKey)
}
}
return nil
}
func (browser *fakeObjectStorageBrowser) GetObjectSummary(_ context.Context, bucket string, key string) (domain.ObjectStorageObjectSummary, error) {
item, ok := browser.objects[bucket+"|"+key]
if !ok {
return domain.ObjectStorageObjectSummary{}, os.ErrNotExist
}
return item, nil
}
func (browser *fakeObjectStorageBrowser) ReadObject(_ context.Context, bucket string, key string) ([]byte, string, error) {
browser.readCalls[bucket+"|"+key]++
if err, ok := browser.readErr[bucket+"|"+key]; ok && err != nil {
return nil, "", err
}
item, ok := browser.objects[bucket+"|"+key]
if !ok {
return nil, "", os.ErrNotExist
}
payload, ok := browser.content[bucket+"|"+key]
if !ok {
return nil, "", os.ErrNotExist
}
return append([]byte(nil), payload...), item.ContentType, nil
}
func (browser *fakeObjectStorageBrowser) ReadObjectPreview(_ context.Context, bucket string, key string, maxBytes int64) ([]byte, string, error) {
browser.readPreviewCalls[bucket+"|"+key]++
browser.lastPreviewMaxLen[bucket+"|"+key] = maxBytes
if err, ok := browser.readErr[bucket+"|"+key]; ok && err != nil {
return nil, "", err
}
item, ok := browser.objects[bucket+"|"+key]
if !ok {
return nil, "", os.ErrNotExist
}
payload, ok := browser.content[bucket+"|"+key]
if !ok {
return nil, "", os.ErrNotExist
}
if maxBytes > 0 && int64(len(payload)) > maxBytes {
payload = payload[:maxBytes]
}
return append([]byte(nil), payload...), item.ContentType, nil
}
func (browser *fakeObjectStorageBrowser) BuildPreviewURL(_ context.Context, bucket string, key string) (string, error) {
if _, ok := browser.objects[bucket+"|"+key]; !ok {
return "", os.ErrNotExist
}
return "https://example.com/preview/" + url.PathEscape(bucket) + "/" + url.PathEscape(key), nil
}
func TestObjectStorageBrowserSupportsConnectionCRUDAndPreview(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
Name: "BOS 管理连接",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
Bucket: "datastorage",
AccessKeyID: "ak-storage-browser",
SecretAccessKey: "sk-storage-browser",
})
if err != nil {
t.Fatalf("create storage connection: %v", err)
}
fakeBrowser := newFakeObjectStorageBrowser()
originalResolver := storageConnectionBrowserResolver
storageConnectionBrowserResolver = func(_ context.Context, item *domain.StorageConnectionRecord) (objectStorageBrowser, func(), error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected storage connection: %#v", item)
}
return fakeBrowser, func() {}, nil
}
t.Cleanup(func() {
storageConnectionBrowserResolver = originalResolver
})
handler := NewHandler(dataStore, nil)
overviewRecorder := httptest.NewRecorder()
handler.ServeHTTP(
overviewRecorder,
httptest.NewRequest(http.MethodGet, "/api/object-storage?connectionId="+connection.ID, nil),
)
if overviewRecorder.Code != http.StatusOK {
t.Fatalf("object storage overview status: %d body=%s", overviewRecorder.Code, overviewRecorder.Body.String())
}
createObjectRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createObjectRecorder,
httptest.NewRequest(http.MethodPost, "/api/object-storage/objects?connectionId="+connection.ID, strings.NewReader(`{"key":"algo/created.json","content":"{\"ok\":true}","contentType":"application/json"}`)),
)
if createObjectRecorder.Code != http.StatusOK {
t.Fatalf("create object status: %d body=%s", createObjectRecorder.Code, createObjectRecorder.Body.String())
}
renameRecorder := httptest.NewRecorder()
handler.ServeHTTP(
renameRecorder,
httptest.NewRequest(http.MethodPatch, "/api/object-storage/objects?connectionId="+connection.ID, strings.NewReader(`{"key":"algo/created.json","newKey":"algo/renamed.json"}`)),
)
if renameRecorder.Code != http.StatusOK {
t.Fatalf("rename object status: %d body=%s", renameRecorder.Code, renameRecorder.Body.String())
}
objectsRecorder := httptest.NewRecorder()
handler.ServeHTTP(
objectsRecorder,
httptest.NewRequest(http.MethodGet, "/api/object-storage/objects?connectionId="+connection.ID+"&prefix=algo", nil),
)
if objectsRecorder.Code != http.StatusOK {
t.Fatalf("list objects status: %d body=%s", objectsRecorder.Code, objectsRecorder.Body.String())
}
contentRecorder := httptest.NewRecorder()
handler.ServeHTTP(
contentRecorder,
httptest.NewRequest(http.MethodGet, "/api/object-storage/content?connectionId="+connection.ID+"&key=algo/renamed.json", nil),
)
if contentRecorder.Code != http.StatusOK {
t.Fatalf("object content status: %d body=%s", contentRecorder.Code, contentRecorder.Body.String())
}
if got := strings.TrimSpace(contentRecorder.Header().Get("Content-Type")); !strings.HasPrefix(got, "application/json") {
t.Fatalf("unexpected content type: %s", got)
}
var multipartBody bytes.Buffer
multipartWriter := multipart.NewWriter(&multipartBody)
fileWriter, err := multipartWriter.CreateFormFile("file", "hello.txt")
if err != nil {
t.Fatalf("create multipart file: %v", err)
}
if _, err := io.WriteString(fileWriter, "hello object storage"); err != nil {
t.Fatalf("write multipart file: %v", err)
}
if err := multipartWriter.Close(); err != nil {
t.Fatalf("close multipart writer: %v", err)
}
uploadRequest := httptest.NewRequest(http.MethodPost, "/api/object-storage/objects/upload?connectionId="+connection.ID+"&key=algo/nested/uploaded.txt", &multipartBody)
uploadRequest.Header.Set("Content-Type", multipartWriter.FormDataContentType())
uploadRecorder := httptest.NewRecorder()
handler.ServeHTTP(uploadRecorder, uploadRequest)
if uploadRecorder.Code != http.StatusOK {
t.Fatalf("upload object status: %d body=%s", uploadRecorder.Code, uploadRecorder.Body.String())
}
deleteObjectRecorder := httptest.NewRecorder()
handler.ServeHTTP(
deleteObjectRecorder,
httptest.NewRequest(http.MethodDelete, "/api/object-storage/objects?connectionId="+connection.ID+"&key=algo/renamed.json", nil),
)
if deleteObjectRecorder.Code != http.StatusOK {
t.Fatalf("delete object status: %d body=%s", deleteObjectRecorder.Code, deleteObjectRecorder.Body.String())
}
deleteDirectoryRecorder := httptest.NewRecorder()
handler.ServeHTTP(
deleteDirectoryRecorder,
httptest.NewRequest(http.MethodDelete, "/api/object-storage/objects?connectionId="+connection.ID+"&key=algo/nested&recursive=true", nil),
)
if deleteDirectoryRecorder.Code != http.StatusOK {
t.Fatalf("delete directory status: %d body=%s", deleteDirectoryRecorder.Code, deleteDirectoryRecorder.Body.String())
}
if _, ok := fakeBrowser.objects["datastorage|algo/nested/uploaded.txt"]; ok {
t.Fatalf("expected recursive directory delete to remove nested object")
}
}
func TestObjectStorageContentStreamsVideoPreviewWithoutReadingWholeObject(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
Name: "BOS 管理连接",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
Bucket: "datastorage",
AccessKeyID: "ak-storage-browser",
SecretAccessKey: "sk-storage-browser",
})
if err != nil {
t.Fatalf("create storage connection: %v", err)
}
fakeBrowser := newFakeObjectStorageBrowser()
videoKey := "algo/demo.mp4"
fakeBrowser.objects["datastorage|"+videoKey] = domain.ObjectStorageObjectSummary{
Bucket: "datastorage",
Key: videoKey,
Name: "demo.mp4",
Kind: "video",
SizeBytes: 7 << 30,
ContentType: "video/mp4",
}
fakeBrowser.readErr["datastorage|"+videoKey] = fmt.Errorf("read should not be called for redirected video preview")
originalResolver := storageConnectionBrowserResolver
storageConnectionBrowserResolver = func(ctx context.Context, item *domain.StorageConnectionRecord) (objectStorageBrowser, func(), error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected storage connection: %#v", item)
}
return fakeBrowser, func() {}, nil
}
defer func() { storageConnectionBrowserResolver = originalResolver }()
previewFile, err := os.CreateTemp(t.TempDir(), "object-storage-preview-*.mp4")
if err != nil {
t.Fatalf("create preview file: %v", err)
}
if _, err := previewFile.Write([]byte("preview-video")); err != nil {
t.Fatalf("write preview file: %v", err)
}
if err := previewFile.Close(); err != nil {
t.Fatalf("close preview file: %v", err)
}
originalPreviewResolver := sourceBrowserVideoPreviewPath
sourceBrowserVideoPreviewPath = func(ctx context.Context, request sourceBrowserPreviewRequest) (string, error) {
if request.RedirectURL == "" {
t.Fatalf("expected redirect url for video preview request")
}
if len(request.Payload) != 0 {
t.Fatalf("expected video preview to avoid in-memory payload reads")
}
return previewFile.Name(), nil
}
defer func() { sourceBrowserVideoPreviewPath = originalPreviewResolver }()
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
request := httptest.NewRequest(
http.MethodGet,
"/api/object-storage/content?connectionId="+url.QueryEscape(connection.ID)+"&bucket=datastorage&key="+url.QueryEscape(videoKey)+"&transcode=browser",
nil,
)
handler.ServeHTTP(recorder, request)
if recorder.Code != http.StatusOK {
t.Fatalf("video preview status: %d body=%s", recorder.Code, recorder.Body.String())
}
if contentType := recorder.Header().Get("Content-Type"); contentType != "video/mp4" {
t.Fatalf("unexpected content type: %s", contentType)
}
if body := recorder.Body.String(); body != "preview-video" {
t.Fatalf("unexpected preview body: %q", body)
}
}
func TestObjectStorageContentPreviewTruncatesLargeJSONObjects(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
connection, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
Name: "BOS 管理连接",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
Bucket: "datastorage",
AccessKeyID: "ak-storage-browser",
SecretAccessKey: "sk-storage-browser",
})
if err != nil {
t.Fatalf("create storage connection: %v", err)
}
fakeBrowser := newFakeObjectStorageBrowser()
largeKey := "algo/large.json"
largePayload := []byte(strings.Repeat(`{"imu":1}`+"\n", 40000))
fakeBrowser.objects["datastorage|"+largeKey] = domain.ObjectStorageObjectSummary{
Bucket: "datastorage",
Key: largeKey,
Name: "large.json",
Kind: "json",
SizeBytes: int64(len(largePayload)),
ContentType: "application/json",
}
fakeBrowser.content["datastorage|"+largeKey] = largePayload
originalResolver := storageConnectionBrowserResolver
storageConnectionBrowserResolver = func(_ context.Context, item *domain.StorageConnectionRecord) (objectStorageBrowser, func(), error) {
if item == nil || item.ID != connection.ID {
t.Fatalf("unexpected storage connection: %#v", item)
}
return fakeBrowser, func() {}, nil
}
defer func() { storageConnectionBrowserResolver = originalResolver }()
handler := NewHandler(dataStore, nil)
recorder := httptest.NewRecorder()
request := httptest.NewRequest(
http.MethodGet,
"/api/object-storage/content?connectionId="+url.QueryEscape(connection.ID)+"&bucket=datastorage&key="+url.QueryEscape(largeKey)+"&preview=true",
nil,
)
handler.ServeHTTP(recorder, request)
if recorder.Code != http.StatusOK {
t.Fatalf("content preview status: %d body=%s", recorder.Code, recorder.Body.String())
}
if fakeBrowser.readCalls["datastorage|"+largeKey] != 0 {
t.Fatalf("expected no full-object reads, got %d", fakeBrowser.readCalls["datastorage|"+largeKey])
}
if fakeBrowser.readPreviewCalls["datastorage|"+largeKey] != 1 {
t.Fatalf("expected one preview read, got %d", fakeBrowser.readPreviewCalls["datastorage|"+largeKey])
}
if got := fakeBrowser.lastPreviewMaxLen["datastorage|"+largeKey]; got != objectStoragePartialPreviewBytes {
t.Fatalf("preview max bytes = %d, want %d", got, objectStoragePartialPreviewBytes)
}
if recorder.Header().Get(objectStoragePreviewTruncatedHeader) != "true" {
t.Fatalf("expected truncated header true, got %q", recorder.Header().Get(objectStoragePreviewTruncatedHeader))
}
if got := recorder.Header().Get(objectStoragePreviewOriginalSizeHeader); got != fmt.Sprintf("%d", len(largePayload)) {
t.Fatalf("unexpected original size header: %q", got)
}
if recorder.Body.Len() != int(objectStoragePartialPreviewBytes) {
t.Fatalf("preview body length = %d, want %d", recorder.Body.Len(), objectStoragePartialPreviewBytes)
}
}
func TestProjectWorkflowAPICreatesConnectionBackedScanWorkflow(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
for _, name := range []string{"BOS 增量扫描", "X 平台数据集索引", "采集目录校验"} {
if _, err := dataStore.CreateOperator(ctx, domain.CreateOperatorInput{
Name: name,
Type: "builtin",
Category: "IO",
Description: name,
Inputs: []domain.PortDefinition{{ID: "in-1", Name: "input", Type: domain.PortTypeJSON}},
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "output", Type: domain.PortTypeJSON}},
}); err != nil {
t.Fatalf("create operator %s: %v", name, err)
}
}
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "连接型扫描项目",
Description: "scan with storage connection",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
connection, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
Name: "BOS 主连接",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
AccessKeyID: "ak-conn-1234",
SecretAccessKey: "sk-conn-5678",
})
if err != nil {
t.Fatalf("create storage connection: %v", err)
}
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"连接型 BOS 扫描",
"description":"使用 connectionId 的扫描 workflow",
"type":"batch",
"kind":"scan",
"schedule":{"interval":600},
"scanConfig":{
"dataSource":"BOS",
"connectionId":"` + connection.ID + `",
"bucket":"datastorage",
"prefix":"algo/X-platform-test/",
"scanMode":"INCREMENTAL",
"incrementalUnit":"DIRECTORY",
"directoryDepth":3,
"enabled":true
},
"nodes":[],
"edges":[]
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("create connection-backed scan workflow status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode created workflow: %v", err)
}
if created.ScanConfig == nil || created.ScanConfig.ConnectionID != connection.ID {
t.Fatalf("expected connection-backed scan config, got %+v", created.ScanConfig)
}
if created.ScanConfig.IncrementalUnit != "DIRECTORY" || created.ScanConfig.DirectoryDepth != 3 {
t.Fatalf("expected connection-backed directory incremental config, got %+v", created.ScanConfig)
}
if created.ScanConfig.AccessKeyID != "" || created.ScanConfig.SecretAccessKey != "" {
t.Fatalf("expected workflow response not to expose secrets: %+v", created.ScanConfig)
}
if created.Type != domain.WorkflowTypeStreaming {
t.Fatalf("expected enabled connection-backed scan workflow to be streaming, got %s", created.Type)
}
stored, err := dataStore.GetWorkflow(ctx, created.ID)
if err != nil {
t.Fatalf("get stored workflow: %v", err)
}
if stored == nil || stored.ScanConfig == nil {
t.Fatalf("expected stored scan config")
}
if stored.ScanConfig.ConnectionID != connection.ID {
t.Fatalf("expected stored connection id, got %+v", stored.ScanConfig)
}
if stored.ScanConfig.IncrementalUnit != "DIRECTORY" || stored.ScanConfig.DirectoryDepth != 3 {
t.Fatalf("expected stored connection-backed directory incremental config, got %+v", stored.ScanConfig)
}
if stored.ScanConfig.AccessKeyID != "" || stored.ScanConfig.SecretAccessKey != "" {
t.Fatalf("expected workflow store to keep connection ref instead of duplicating secrets: %+v", stored.ScanConfig)
}
runRecorder := httptest.NewRecorder()
handler.ServeHTTP(
runRecorder,
httptest.NewRequest(http.MethodPost, "/api/workflows/"+created.ID+"/run", bytes.NewReader([]byte(`{"trigger":"manual"}`))),
)
if runRecorder.Code != http.StatusAccepted {
t.Fatalf("run connection-backed scan workflow status: %d body=%s", runRecorder.Code, runRecorder.Body.String())
}
}
func TestProjectWorkflowAPIRejectsUnknownNodeStorageConnection(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "连接校验项目",
Description: "reject invalid node connection",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"无效连接工作流",
"description":"节点 connectionId 应该校验",
"type":"batch",
"nodes":[
{
"id":"node-oss",
"type":"operator",
"data":{
"label":"OSS 数据源",
"category":"IO",
"description":"source",
"connectionId":"connection-missing",
"inputs":[],
"outputs":[],
"hyperparams":[]
},
"position":{"x":0,"y":0}
}
],
"edges":[]
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusBadRequest {
t.Fatalf("expected validation failure, got %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
if !strings.Contains(createRecorder.Body.String(), "connectionId") {
t.Fatalf("expected connectionId issue, body=%s", createRecorder.Body.String())
}
}
func duplicateInputEdgeWorkflowNodes() []domain.WorkflowNode {
return []domain.WorkflowNode{
{
ID: "source-a",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "上游 A",
Category: "IO",
Description: "source a",
Inputs: []domain.PortDefinition{},
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "result", Type: domain.PortTypeJSON}},
},
Position: domain.Position{X: 0, Y: 0},
},
{
ID: "source-b",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "上游 B",
Category: "IO",
Description: "source b",
Inputs: []domain.PortDefinition{},
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "result", Type: domain.PortTypeJSON}},
},
Position: domain.Position{X: 120, Y: 0},
},
{
ID: "upload",
Type: "operator",
Data: domain.WorkflowNodeData{
Label: "结果上传",
Category: "IO",
Description: "upload",
Inputs: []domain.PortDefinition{{ID: "in-1", Name: "result", Type: domain.PortTypeJSON}},
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "uploaded", Type: domain.PortTypeJSON}},
},
Position: domain.Position{X: 240, Y: 0},
},
}
}
func duplicateInputEdgeWorkflowEdges() []domain.WorkflowEdge {
return []domain.WorkflowEdge{
{ID: "edge-a", Source: "source-a", SourceHandle: "out-1", Target: "upload", TargetHandle: "in-1"},
{ID: "edge-b", Source: "source-b", SourceHandle: "out-1", Target: "upload", TargetHandle: "in-1"},
}
}
func TestProjectWorkflowAPIRejectsDuplicateIncomingEdgesPerInputPort(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "重复输入端口项目",
Description: "reject duplicate input edges",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
payload, err := json.Marshal(domain.CreateWorkflowInput{
Name: "非法上传工作流",
Description: "duplicate input edges",
Type: domain.WorkflowTypeBatch,
Nodes: duplicateInputEdgeWorkflowNodes(),
Edges: duplicateInputEdgeWorkflowEdges(),
})
if err != nil {
t.Fatalf("marshal payload: %v", err)
}
recorder := httptest.NewRecorder()
NewHandler(dataStore, nil).ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(payload)),
)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("expected validation failure, got %d body=%s", recorder.Code, recorder.Body.String())
}
if !strings.Contains(recorder.Body.String(), "每个输入端口只能连接一条上游连线") {
t.Fatalf("expected duplicate input edge validation, body=%s", recorder.Body.String())
}
if !strings.Contains(recorder.Body.String(), "上传算子") {
t.Fatalf("expected upload node guidance, body=%s", recorder.Body.String())
}
}
func TestWorkflowUpdateRejectsDuplicateIncomingEdgesPerInputPort(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "更新重复输入端口项目",
Description: "reject duplicate input edges on update",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "合法工作流",
Description: "valid before update",
Type: domain.WorkflowTypeBatch,
Nodes: duplicateInputEdgeWorkflowNodes(),
Edges: []domain.WorkflowEdge{
{ID: "edge-a", Source: "source-a", SourceHandle: "out-1", Target: "upload", TargetHandle: "in-1"},
},
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
payload, err := json.Marshal(map[string]any{
"nodes": duplicateInputEdgeWorkflowNodes(),
"edges": duplicateInputEdgeWorkflowEdges(),
})
if err != nil {
t.Fatalf("marshal payload: %v", err)
}
recorder := httptest.NewRecorder()
NewHandler(dataStore, nil).ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPut, "/api/workflows/"+workflow.ID, bytes.NewReader(payload)),
)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("expected update validation failure, got %d body=%s", recorder.Code, recorder.Body.String())
}
if !strings.Contains(recorder.Body.String(), "每个输入端口只能连接一条上游连线") {
t.Fatalf("expected duplicate input edge validation, body=%s", recorder.Body.String())
}
}
func TestWorkflowRunRejectsDuplicateIncomingEdgesPerInputPort(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "运行重复输入端口项目",
Description: "reject duplicate input edges on run",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
ProjectID: project.ID,
Name: "非法运行工作流",
Description: "invalid graph",
Type: domain.WorkflowTypeBatch,
Nodes: duplicateInputEdgeWorkflowNodes(),
Edges: duplicateInputEdgeWorkflowEdges(),
})
if err != nil {
t.Fatalf("create workflow: %v", err)
}
recorder := httptest.NewRecorder()
NewHandler(dataStore, nil).ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/workflows/"+workflow.ID+"/run", bytes.NewReader([]byte(`{"trigger":"manual"}`))),
)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("expected run validation failure, got %d body=%s", recorder.Code, recorder.Body.String())
}
if !strings.Contains(recorder.Body.String(), "每个输入端口只能连接一条上游连线") {
t.Fatalf("expected duplicate input edge validation, body=%s", recorder.Body.String())
}
}
func TestTemplateCreateRejectsDuplicateIncomingEdgesPerInputPort(t *testing.T) {
dataStore := store.NewMemoryStore()
payload, err := json.Marshal(domain.CreateTemplateInput{
Name: "非法模板",
Description: "duplicate input edges",
Type: domain.WorkflowTypeBatch,
Nodes: duplicateInputEdgeWorkflowNodes(),
Edges: duplicateInputEdgeWorkflowEdges(),
})
if err != nil {
t.Fatalf("marshal payload: %v", err)
}
recorder := httptest.NewRecorder()
NewHandler(dataStore, nil).ServeHTTP(
recorder,
httptest.NewRequest(http.MethodPost, "/api/templates", bytes.NewReader(payload)),
)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("expected template validation failure, got %d body=%s", recorder.Code, recorder.Body.String())
}
if !strings.Contains(recorder.Body.String(), "每个输入端口只能连接一条上游连线") {
t.Fatalf("expected duplicate input edge validation, body=%s", recorder.Body.String())
}
}
func TestProjectWorkflowAPICreatesScanDraftAndBlocksRunUntilConfigured(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
for _, name := range []string{"BOS 增量扫描", "X 平台数据集索引", "采集目录校验"} {
if _, err := dataStore.CreateOperator(ctx, domain.CreateOperatorInput{
Name: name,
Type: "builtin",
Category: "IO",
Description: name,
Inputs: []domain.PortDefinition{{ID: "in-1", Name: "input", Type: domain.PortTypeJSON}},
Outputs: []domain.PortDefinition{{ID: "out-1", Name: "output", Type: domain.PortTypeJSON}},
}); err != nil {
t.Fatalf("create operator %s: %v", name, err)
}
}
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
Name: "扫描草稿项目",
Description: "scan draft",
})
if err != nil {
t.Fatalf("create project: %v", err)
}
handler := NewHandler(dataStore, nil)
createPayload := []byte(`{
"name":"扫描草稿",
"description":"先创建后配置",
"type":"batch",
"kind":"scan",
"schedule":{"interval":0},
"scanConfig":{
"dataSource":"BOS",
"endpoint":"https://bj.bcebos.com",
"scanMode":"INCREMENTAL",
"enabled":false
},
"nodes":[],
"edges":[]
}`)
createRecorder := httptest.NewRecorder()
handler.ServeHTTP(
createRecorder,
httptest.NewRequest(http.MethodPost, "/api/projects/"+project.ID+"/workflows", bytes.NewReader(createPayload)),
)
if createRecorder.Code != http.StatusCreated {
t.Fatalf("create scan draft status: %d body=%s", createRecorder.Code, createRecorder.Body.String())
}
var created domain.WorkflowRecord
if err := json.Unmarshal(createRecorder.Body.Bytes(), &created); err != nil {
t.Fatalf("decode scan draft: %v", err)
}
if created.Kind != domain.WorkflowKindScan {
t.Fatalf("expected scan kind, got %s", created.Kind)
}
if created.ScanConfig == nil {
t.Fatalf("expected scan config")
}
if created.ScanConfig.Bucket != "" || created.ScanConfig.Prefix != "" {
t.Fatalf("expected incomplete draft scan target, got %+v", created.ScanConfig)
}
if created.Type != domain.WorkflowTypeBatch {
t.Fatalf("expected draft scan workflow to stay batch, got %s", created.Type)
}
if len(created.Nodes) != 3 {
t.Fatalf("expected scaffolded scan nodes, got %d", len(created.Nodes))
}
runRecorder := httptest.NewRecorder()
handler.ServeHTTP(
runRecorder,
httptest.NewRequest(http.MethodPost, "/api/workflows/"+created.ID+"/run", bytes.NewReader([]byte(`{"trigger":"manual"}`))),
)
if runRecorder.Code != http.StatusBadRequest {
t.Fatalf("expected scan draft run to be rejected, got %d body=%s", runRecorder.Code, runRecorder.Body.String())
}
if !strings.Contains(runRecorder.Body.String(), "扫描源配置未完成") {
t.Fatalf("expected missing scan config error, got %s", runRecorder.Body.String())
}
}
func TestSettingsRejectsInvalidTimezone(t *testing.T) {
dataStore := store.NewMemoryStore()
handler := NewHandler(dataStore, nil)
updateRecorder := httptest.NewRecorder()
updateRequest := httptest.NewRequest(
http.MethodPut,
"/api/settings",
bytes.NewReader([]byte(`{"timezone":"Mars/Base"}`)),
)
handler.ServeHTTP(updateRecorder, updateRequest)
if updateRecorder.Code != http.StatusBadRequest {
t.Fatalf("expected invalid timezone to fail, got %d body=%s", updateRecorder.Code, updateRecorder.Body.String())
}
}