droboticflow/internal/api/poc_operator_workflow_acceptance_test.go
2026-07-13 17:10:17 +08:00

719 lines
32 KiB
Go

package api
import (
"context"
"os"
"path/filepath"
"strings"
"testing"
"droboticflow/internal/domain"
"droboticflow/internal/store"
)
func TestConfigurePocOperatorHyperparamsRoutesSegmentationFixture(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
fixtures.Extra["segmentation"] = "/workspace/datasets/fixtures/poc-operator-acceptance/segmentation"
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-segmentation-mask-validate",
Name: "分割 Mask 校验",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "SOURCE_PATH"); value != "/workspace/datasets/fixtures/poc-operator-acceptance/segmentation" {
t.Fatalf("SOURCE_PATH = %q", value)
}
if value := hyperparamValue(params, "MAX_PAIRS"); value != "2" {
t.Fatalf("MAX_PAIRS = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsRoutesTFRecordFixture(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
fixtures.Extra["tfrecord"] = "/workspace/datasets/fixtures/poc-operator-acceptance/tfrecord"
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-tfrecord-structural-validate",
Name: "TFRecord 结构校验",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "SOURCE_PATH"); value != "/workspace/datasets/fixtures/poc-operator-acceptance/tfrecord" {
t.Fatalf("SOURCE_PATH = %q", value)
}
if value := hyperparamValue(params, "MAX_RECORDS"); value != "10" {
t.Fatalf("MAX_RECORDS = %q", value)
}
if value := hyperparamValue(params, "PREVIEW_RECORDS"); value != "2" {
t.Fatalf("PREVIEW_RECORDS = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsRoutesMongoToPlatform(t *testing.T) {
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-mongodb-write",
Name: "MongoDB 写入",
Type: "builtin",
}, pocOperatorAcceptanceFixturePaths{})
if value := hyperparamValue(params, "MONGO_TARGET"); value != "platform" {
t.Fatalf("MONGO_TARGET = %q", value)
}
if value := hyperparamValue(params, "MONGO_COLLECTION"); value != "operatorWorkflowAcceptanceWrites" {
t.Fatalf("MONGO_COLLECTION = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsBoundsDatasetSplitManifest(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-dataset-split-manifest",
Name: "训练切分清单生成",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "SOURCE_PATH"); value != fixtures.JSON {
t.Fatalf("SOURCE_PATH = %q, want %q", value, fixtures.JSON)
}
if value := hyperparamValue(params, "MIN_STEPS"); value != "0" {
t.Fatalf("MIN_STEPS = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsBoundsLeRobotVideoAlignment(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-lerobot-video-alignment-validate",
Name: "LeRobot 视频对齐校验",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "SOURCE_PATH"); value != fixtures.LeRobot {
t.Fatalf("SOURCE_PATH = %q, want %q", value, fixtures.LeRobot)
}
for key, want := range map[string]string{"MAX_PARQUET_FILES": "1", "MAX_ROWS": "1", "MAX_VIDEOS": "1"} {
if value := hyperparamValue(params, key); value != want {
t.Fatalf("%s = %q, want %q", key, value, want)
}
}
}
func TestConfigurePocOperatorHyperparamsRoutesYOLODataYaml(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
fixtures.Extra["yolo_data_yaml"] = "/workspace/datasets/fixtures/poc-operator-acceptance/yolo/coco128/data.yaml"
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-yolo-embodied-detection-train",
Name: "YOLO 具身目标检测训练",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "DATA_YAML"); value != "/workspace/datasets/fixtures/poc-operator-acceptance/yolo/coco128/data.yaml" {
t.Fatalf("DATA_YAML = %q", value)
}
if value := hyperparamValue(params, "WORKERS"); value != "0" {
t.Fatalf("WORKERS = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsRoutesProductionTrainingFixture(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
fixtures.Extra["training_json"] = "/workspace/datasets/fixtures/poc-operator-acceptance/json/training-records.json"
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-act-policy-train",
Name: "ACT 策略训练",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "DATASET_PATH"); value != "/workspace/datasets/fixtures/poc-operator-acceptance/json/training-records.json" {
t.Fatalf("DATASET_PATH = %q", value)
}
if value := hyperparamValue(params, "STATE_FIELD"); value != "state" {
t.Fatalf("STATE_FIELD = %q", value)
}
if value := hyperparamValue(params, "ACTION_FIELD"); value != "action" {
t.Fatalf("ACTION_FIELD = %q", value)
}
if value := hyperparamValue(params, "BATCH_SIZE"); value != "16" {
t.Fatalf("BATCH_SIZE = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsRoutesYOLOONNXModel(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
fixtures.Extra["yolo_onnx_model"] = "/workspace/datasets/fixtures/poc-operator-acceptance/yolo/models/yolov8n.onnx"
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-yolo-video-target-clip",
Name: "YOLO 视频目标检测裁剪",
Type: "builtin",
}, fixtures)
if value := hyperparamValue(params, "POC_ACCEPTANCE_MODE"); value != "" {
t.Fatalf("POC_ACCEPTANCE_MODE = %q", value)
}
if value := hyperparamValue(params, "DETECTION_MODE"); value != "opencv-dnn" {
t.Fatalf("DETECTION_MODE = %q", value)
}
if value := hyperparamValue(params, "DNN_MODEL_PATH"); value != "/workspace/datasets/fixtures/poc-operator-acceptance/yolo/models/yolov8n.onnx" {
t.Fatalf("DNN_MODEL_PATH = %q", value)
}
if value := hyperparamValue(params, "TARGET_LABELS"); value != "*" {
t.Fatalf("TARGET_LABELS = %q", value)
}
}
func TestConfigurePocOperatorHyperparamsUsesManifestShellCommand(t *testing.T) {
params := configurePocOperatorHyperparams(domain.OperatorRecord{
ID: "operator-builtin-shell-command",
Name: "Shell 命令",
Type: "builtin",
}, pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json"))
if value := hyperparamValue(params, "SCRIPT_ID"); value != "fixture_report" {
t.Fatalf("SCRIPT_ID = %q", value)
}
if value := hyperparamValue(params, "SCRIPT_ARGS_JSON"); value == "" {
t.Fatalf("SCRIPT_ARGS_JSON should be configured")
}
if value := hyperparamValue(params, "INPUT_PATHS_JSON"); !strings.Contains(value, "poc-operator-acceptance.json") {
t.Fatalf("INPUT_PATHS_JSON = %q", value)
}
}
func TestIncludePocOperatorInWorkflowAcceptanceIncludesShellWithBuiltinCoverage(t *testing.T) {
operator := domain.OperatorRecord{ID: "operator-builtin-shell-command", Name: "Shell 命令", Type: "builtin"}
if !includePocOperatorInWorkflowAcceptance(operator, false) {
t.Fatalf("shell command should be included for 96/96 builtin coverage")
}
if !includePocOperatorInWorkflowAcceptance(operator, true) {
t.Fatalf("shell command should remain included when explicitly requested")
}
if includePocOperatorInWorkflowAcceptance(domain.OperatorRecord{ID: "custom-1", Type: "custom"}, true) {
t.Fatalf("non-builtin operator should be excluded")
}
}
func TestBuildPocOperatorWorkflowEdgesConnectsShellToMongo(t *testing.T) {
edges := buildPocOperatorWorkflowEdges("外部存储与审计链路", []domain.OperatorRecord{
{ID: "operator-builtin-bos-incremental-scan", Name: "BOS 增量扫描", Type: "builtin"},
{ID: "operator-builtin-mongodb-write", Name: "MongoDB 写入", Type: "builtin"},
{ID: "operator-builtin-shell-command", Name: "Shell 命令", Type: "builtin"},
})
if len(edges) != 2 {
t.Fatalf("edges length = %d", len(edges))
}
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-shell-command", "op-bos-incremental-scan"),
pocOperatorWorkflowEdge("op-bos-incremental-scan", "op-mongodb-write"),
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
}
func TestBuildPocOperatorWorkflowEdgesConnectsExternalAudit(t *testing.T) {
edges := buildPocOperatorWorkflowEdges("外部存储与审计链路", []domain.OperatorRecord{
{ID: "operator-builtin-bos-incremental-scan", Name: "BOS 增量扫描", Type: "builtin"},
{ID: "operator-builtin-dataset-provenance-audit", Name: "数据血缘审计", Type: "builtin"},
{ID: "operator-builtin-mongodb-write", Name: "MongoDB 写入", Type: "builtin"},
{ID: "operator-builtin-shell-command", Name: "Shell 命令", Type: "builtin"},
})
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-shell-command", "op-bos-incremental-scan"),
pocOperatorWorkflowEdge("op-bos-incremental-scan", "op-mongodb-write"),
pocOperatorWorkflowEdge("op-mongodb-write", "op-dataset-provenance-audit"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
}
func TestBuildPocOperatorWorkflowEdgesConnectsVLADataFlow(t *testing.T) {
operators := []domain.OperatorRecord{
{ID: "operator-builtin-vla-model-evaluate", Name: "VLA 模型评测", Type: "builtin"},
{ID: "operator-builtin-vla-model-inference", Name: "VLA 模型推理", Type: "builtin"},
{ID: "operator-builtin-vla-model-train", Name: "VLA 模型训练", Type: "builtin"},
{ID: "operator-builtin-sim3d-asset-generate", Name: "3D 资产仿真生成", Type: "builtin"},
}
edges := buildPocOperatorWorkflowEdges("VLA训练推理评测链路", operators)
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-vla-model-train", "op-vla-model-inference"),
pocOperatorWorkflowEdge("op-vla-model-inference", "op-vla-model-evaluate"),
pocOperatorWorkflowEdge("op-vla-model-evaluate", "op-sim3d-asset-generate"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
assertPocWorkflowEdgesSingleMainChain(t, edges)
}
func TestBuildPocOperatorWorkflowEdgesConnectsOpenVLAChainToVLAChain(t *testing.T) {
operators := []domain.OperatorRecord{
{ID: "operator-builtin-act-policy-train", Name: "ACT 策略训练", Type: "builtin"},
{ID: "operator-builtin-diffusion-policy-train", Name: "Diffusion Policy 训练", Type: "builtin"},
{ID: "operator-builtin-openvla-finetune", Name: "OpenVLA 微调训练", Type: "builtin"},
{ID: "operator-builtin-openvla-inference", Name: "OpenVLA 推理", Type: "builtin"},
{ID: "operator-builtin-vla-model-train", Name: "VLA 模型训练", Type: "builtin"},
{ID: "operator-builtin-vla-model-inference", Name: "VLA 模型推理", Type: "builtin"},
{ID: "operator-builtin-vla-model-evaluate", Name: "VLA 模型评测", Type: "builtin"},
}
edges := buildPocOperatorWorkflowEdges("VLA训练推理评测链路", operators)
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-act-policy-train", "op-diffusion-policy-train"),
pocOperatorWorkflowEdge("op-diffusion-policy-train", "op-openvla-finetune"),
pocOperatorWorkflowEdge("op-openvla-finetune", "op-openvla-inference"),
pocOperatorWorkflowEdge("op-openvla-inference", "op-vla-model-train"),
pocOperatorWorkflowEdge("op-vla-model-train", "op-vla-model-inference"),
pocOperatorWorkflowEdge("op-vla-model-inference", "op-vla-model-evaluate"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
assertPocWorkflowEdgesSingleMainChain(t, edges)
}
func TestBuildPocOperatorWorkflowInputLimitsAcceptanceConcurrency(t *testing.T) {
project := &domain.ProjectRecord{ID: "project-1", OrganizationID: "org-1"}
workflow := buildPocOperatorWorkflowInput(project, "数据接入与格式转换链路", []domain.OperatorRecord{
{ID: "operator-builtin-json-filter", Name: "JSON 过滤", Type: "builtin"},
{ID: "operator-builtin-json-map-rename", Name: "JSON 字段映射", Type: "builtin"},
}, pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json"), nil)
if workflow.MaxConcurrentRuns != pocOperatorWorkflowAcceptanceMaxConcurrentRuns {
t.Fatalf("MaxConcurrentRuns = %d, want %d", workflow.MaxConcurrentRuns, pocOperatorWorkflowAcceptanceMaxConcurrentRuns)
}
}
func TestBuildPocOperatorWorkflowInputLaysOutSingleHorizontalChain(t *testing.T) {
project := &domain.ProjectRecord{ID: "project-1", OrganizationID: "org-1"}
workflow := buildPocOperatorWorkflowInput(project, "数据接入与格式转换链路", []domain.OperatorRecord{
{ID: "operator-builtin-json-filter", Name: "JSON 过滤", Type: "builtin"},
{ID: "operator-builtin-json-map-rename", Name: "JSON 字段映射", Type: "builtin"},
{ID: "operator-builtin-template-render", Name: "文本模板渲染", Type: "builtin"},
}, pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json"), nil)
if len(workflow.Nodes) != 3 {
t.Fatalf("nodes = %d, want 3", len(workflow.Nodes))
}
for index, node := range workflow.Nodes {
if node.Position.Y != 0 {
t.Fatalf("node[%d] Y = %v, want 0", index, node.Position.Y)
}
wantX := float64(index * 300)
if node.Position.X != wantX {
t.Fatalf("node[%d] X = %v, want %v", index, node.Position.X, wantX)
}
}
assertPocWorkflowEdgesSingleMainChain(t, workflow.Edges)
}
func TestBuildPocOperatorWorkflowEdgesSerializesDatasetBatches(t *testing.T) {
edges := buildPocOperatorWorkflowEdges("具身数据集结构校验链路一", []domain.OperatorRecord{
{ID: "operator-builtin-calvin-episode-validate", Name: "CALVIN Episode 校验", Type: "builtin"},
{ID: "operator-builtin-libero-hdf5-task-validate", Name: "LIBERO HDF5 校验", Type: "builtin"},
{ID: "operator-builtin-maniskill-trajectory-validate", Name: "ManiSkill 轨迹校验", Type: "builtin"},
})
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-calvin-episode-validate", "op-libero-hdf5-task-validate"),
pocOperatorWorkflowEdge("op-libero-hdf5-task-validate", "op-maniskill-trajectory-validate"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
assertPocWorkflowEdgesSingleMainChain(t, edges)
}
func TestBuildPocOperatorWorkflowEdgesConnectsVideoPipelineCatalogIDs(t *testing.T) {
if got := pocOperatorHandlerKey(domain.OperatorRecord{ID: "operator-builtin-xplatform-dataset-index", Name: "X 平台数据集索引", Type: "builtin"}); got != "builtin_xplatform_index" {
t.Fatalf("xplatform index handler = %q", got)
}
if got := pocOperatorHandlerKey(domain.OperatorRecord{ID: "operator-builtin-xplatform-dataset-validate", Name: "采集目录校验", Type: "builtin"}); got != "builtin_collection_validate" {
t.Fatalf("xplatform validate handler = %q", got)
}
operators := []domain.OperatorRecord{
{ID: "operator-builtin-xplatform-dataset-index", Name: "X 平台数据集索引", Type: "builtin"},
{ID: "operator-builtin-xplatform-dataset-validate", Name: "采集目录校验", Type: "builtin"},
{ID: "operator-builtin-video-quality", Name: "视频质检", Type: "builtin"},
{ID: "operator-builtin-video-filter", Name: "数据过滤", Type: "builtin"},
{ID: "operator-builtin-video-slice", Name: "视频切片", Type: "builtin"},
{ID: "operator-builtin-video-annotate", Name: "视频标注", Type: "builtin"},
{ID: "operator-builtin-video-target-clip", Name: "视频目标检测裁剪", Type: "builtin"},
{ID: "operator-builtin-yolo-video-target-clip", Name: "YOLO 视频目标检测裁剪", Type: "builtin"},
{ID: "operator-builtin-package", Name: "成品打包", Type: "builtin"},
{ID: "operator-builtin-audit-sample", Name: "抽检采样", Type: "builtin"},
}
nodeByHandler := map[string]string{}
for _, operator := range operators {
nodeByHandler[pocOperatorHandlerKey(operator)] = operatorNodeID(operator)
}
if nodeByHandler["builtin_xplatform_index"] == "" || nodeByHandler["builtin_collection_validate"] == "" {
t.Fatalf("nodeByHandler missing xplatform nodes: %#v", nodeByHandler)
}
edges := buildPocOperatorWorkflowEdges("视频检测裁剪与成品链路", operators)
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-xplatform-dataset-index", "op-xplatform-dataset-validate"),
pocOperatorWorkflowEdge("op-xplatform-dataset-validate", "op-video-quality"),
pocOperatorWorkflowEdge("op-video-quality", "op-video-filter"),
pocOperatorWorkflowEdge("op-video-filter", "op-video-slice"),
pocOperatorWorkflowEdge("op-video-slice", "op-video-target-clip"),
pocOperatorWorkflowEdge("op-video-target-clip", "op-yolo-video-target-clip"),
pocOperatorWorkflowEdge("op-yolo-video-target-clip", "op-video-annotate"),
pocOperatorWorkflowEdge("op-video-annotate", "op-package"),
pocOperatorWorkflowEdge("op-package", "op-audit-sample"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
assertPocWorkflowEdgesSingleMainChain(t, edges)
}
func TestBuildPocOperatorWorkflowEdgesConnectsHumanReviewToRealPackageInput(t *testing.T) {
operators := []domain.OperatorRecord{
{ID: "operator-builtin-xplatform-dataset-index", Name: "X 平台数据集索引", Type: "builtin"},
{ID: "operator-builtin-xplatform-dataset-validate", Name: "采集目录校验", Type: "builtin"},
{ID: "operator-builtin-video-quality", Name: "视频质检", Type: "builtin"},
{ID: "operator-builtin-video-filter", Name: "数据过滤", Type: "builtin"},
{ID: "operator-builtin-video-slice", Name: "视频切片", Type: "builtin"},
{ID: "operator-builtin-video-annotate", Name: "视频标注", Type: "builtin"},
{ID: "operator-builtin-video-target-clip", Name: "视频目标检测裁剪", Type: "builtin"},
{ID: "operator-builtin-yolo-video-target-clip", Name: "YOLO 视频目标检测裁剪", Type: "builtin"},
{ID: "operator-builtin-package", Name: "成品打包", Type: "builtin"},
{ID: "operator-builtin-audit-sample", Name: "抽检采样", Type: "builtin"},
{ID: "operator-builtin-human-review", Name: "人工审核", Type: "builtin"},
}
edges := buildPocOperatorWorkflowEdges("人工审核与抽检链路", operators)
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-xplatform-dataset-index", "op-xplatform-dataset-validate"),
pocOperatorWorkflowEdge("op-xplatform-dataset-validate", "op-video-quality"),
pocOperatorWorkflowEdge("op-video-quality", "op-video-filter"),
pocOperatorWorkflowEdge("op-video-filter", "op-video-slice"),
pocOperatorWorkflowEdge("op-video-slice", "op-video-target-clip"),
pocOperatorWorkflowEdge("op-video-target-clip", "op-yolo-video-target-clip"),
pocOperatorWorkflowEdge("op-yolo-video-target-clip", "op-video-annotate"),
pocOperatorWorkflowEdge("op-video-annotate", "op-package"),
pocOperatorWorkflowEdge("op-package", "op-audit-sample"),
pocOperatorWorkflowEdge("op-audit-sample", "op-human-review"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
assertPocWorkflowEdgesSingleMainChain(t, edges)
}
func TestBuildPocOperatorWorkflowEdgesFallsBackWhenYOLOIsAbsent(t *testing.T) {
operators := []domain.OperatorRecord{
{ID: "operator-builtin-xplatform-dataset-index", Name: "X 平台数据集索引", Type: "builtin"},
{ID: "operator-builtin-xplatform-dataset-validate", Name: "采集目录校验", Type: "builtin"},
{ID: "operator-builtin-video-quality", Name: "视频质检", Type: "builtin"},
{ID: "operator-builtin-video-filter", Name: "数据过滤", Type: "builtin"},
{ID: "operator-builtin-video-slice", Name: "视频切片", Type: "builtin"},
{ID: "operator-builtin-video-annotate", Name: "视频标注", Type: "builtin"},
{ID: "operator-builtin-video-target-clip", Name: "视频目标检测裁剪", Type: "builtin"},
{ID: "operator-builtin-package", Name: "成品打包", Type: "builtin"},
{ID: "operator-builtin-audit-sample", Name: "抽检采样", Type: "builtin"},
}
edges := buildPocOperatorWorkflowEdges("视频检测裁剪与成品链路", operators)
want := []domain.WorkflowEdge{
pocOperatorWorkflowEdge("op-xplatform-dataset-index", "op-xplatform-dataset-validate"),
pocOperatorWorkflowEdge("op-xplatform-dataset-validate", "op-video-quality"),
pocOperatorWorkflowEdge("op-video-quality", "op-video-filter"),
pocOperatorWorkflowEdge("op-video-filter", "op-video-slice"),
pocOperatorWorkflowEdge("op-video-slice", "op-video-target-clip"),
pocOperatorWorkflowEdge("op-video-target-clip", "op-video-annotate"),
pocOperatorWorkflowEdge("op-video-annotate", "op-package"),
pocOperatorWorkflowEdge("op-package", "op-audit-sample"),
}
if len(edges) != len(want) {
t.Fatalf("edges length = %d, want %d: %#v", len(edges), len(want), edges)
}
for index := range want {
if edges[index] != want[index] {
t.Fatalf("edge[%d] = %#v, want %#v", index, edges[index], want[index])
}
}
assertPocWorkflowEdgesSingleMainChain(t, edges)
}
func TestGroupPocOperatorAcceptanceBatchesRoutesXPlatformValidationToVideoPipeline(t *testing.T) {
batches := groupPocOperatorAcceptanceBatches([]domain.OperatorRecord{
{ID: "operator-builtin-xplatform-dataset-validate", Name: "采集目录校验", Type: "builtin", Category: "DATASET"},
})
if len(batches["视频检测裁剪与成品链路"]) != 1 {
t.Fatalf("视频检测裁剪与成品链路 batch = %#v", batches["视频检测裁剪与成品链路"])
}
if len(batches["具身数据集结构校验链路一"])+len(batches["具身数据集结构校验链路二"])+len(batches["具身数据集结构校验链路三"]) != 0 {
t.Fatalf("xplatform validate should not be routed to dataset batches: %#v", batches)
}
}
func TestGroupPocOperatorAcceptanceBatchesAddsHumanReviewPackageSupport(t *testing.T) {
batches := groupPocOperatorAcceptanceBatches([]domain.OperatorRecord{
{ID: "operator-builtin-human-review", Name: "人工审核", Type: "builtin"},
{ID: "operator-builtin-audit-sample", Name: "抽检采样", Type: "builtin"},
{ID: "operator-builtin-xplatform-dataset-index", Name: "X 平台数据集索引", Type: "builtin", Category: "VIDEO"},
{ID: "operator-builtin-package", Name: "成品打包", Type: "builtin", Category: "VIDEO"},
{ID: "operator-builtin-video-target-clip", Name: "视频目标检测裁剪", Type: "builtin", Category: "VIDEO"},
{ID: "operator-builtin-yolo-video-target-clip", Name: "YOLO 视频目标检测裁剪", Type: "builtin", Category: "VIDEO"},
})
handlerSet := map[string]bool{}
for _, operator := range batches["人工审核与抽检链路"] {
handlerSet[pocOperatorHandlerKey(operator)] = true
}
for _, handler := range []string{"builtin_human_review", "builtin_audit_sampling", "builtin_xplatform_index", "builtin_video_target_clip", "builtin_yolo_video_target_clip", "builtin_result_package"} {
if !handlerSet[handler] {
t.Fatalf("人工审核与抽检链路 missing support handler %s in %#v", handler, batches["人工审核与抽检链路"])
}
}
}
func TestWorkflowNodeFromOperatorScopesBOSScanToAcceptancePrefix(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
connection := &domain.StorageConnectionRecord{
ID: "storage-poc-bos-workspace",
Bucket: "testxyz",
}
node := workflowNodeFromOperator(domain.OperatorRecord{
ID: "operator-builtin-bos-incremental-scan",
Name: "BOS 增量扫描",
Type: "builtin",
}, fixtures, connection, 0, 0)
if node.Data.ConnectionID != connection.ID {
t.Fatalf("connectionID = %q", node.Data.ConnectionID)
}
if node.Data.Bucket != "testxyz" {
t.Fatalf("bucket = %q", node.Data.Bucket)
}
if value := hyperparamValue(node.Data.Hyperparams, "SOURCE_PATH"); value != "bos://testxyz/datasets/fixtures/poc-operator-acceptance/xplatform" {
t.Fatalf("SOURCE_PATH = %q", value)
}
}
func TestFirstPocOperatorAcceptanceStorageConnectionRequiresBucket(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
server := &server{store: dataStore}
if _, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
OrganizationID: "org-1",
Name: "bucketless",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
AccessKeyID: "ak-bucketless",
SecretAccessKey: "sk-bucketless",
}); err != nil {
t.Fatalf("create bucketless storage connection: %v", err)
}
expected, err := dataStore.CreateStorageConnection(ctx, domain.CreateStorageConnectionInput{
OrganizationID: "org-1",
Name: "workspace",
Provider: domain.StorageProviderBOS,
Endpoint: "https://bj.bcebos.com",
Bucket: "testxyz",
AccessKeyID: "ak-workspace",
SecretAccessKey: "sk-workspace",
})
if err != nil {
t.Fatalf("create workspace storage connection: %v", err)
}
connection, err := server.firstPocOperatorAcceptanceStorageConnection(ctx, "org-1")
if err != nil {
t.Fatalf("firstPocOperatorAcceptanceStorageConnection: %v", err)
}
if connection == nil || connection.ID != expected.ID {
t.Fatalf("connection = %#v, want %#v", connection, expected)
}
}
func TestWorkflowNodeFromOperatorCopiesDefaultGPUResources(t *testing.T) {
fixtures := pocOperatorAcceptanceFixturePathsFromManifest("/workspace/datasets/fixtures/poc-operator-acceptance/poc-operator-acceptance.json")
node := workflowNodeFromOperator(domain.OperatorRecord{
ID: "operator-builtin-act-policy-train",
Name: "ACT 策略训练",
Type: "builtin",
Category: "AI",
Image: "ccr.example/droboticflow-operator-act-policy-train:v1",
ImageID: "ccr.example/droboticflow-operator-act-policy-train@sha256:abc123",
ContainerCommand: []string{
"python",
"/app/backend/operator-runner/main.py",
},
ContainerArgs: []string{"--strict"},
Resources: &domain.OperatorResources{
CPULimit: "16",
MemoryLimit: "64Gi",
GPULimit: "1",
},
}, fixtures, nil, 0, 0)
if node.Data.CPU != "16" || node.Data.Memory != "64Gi" || node.Data.GPU != "1" {
t.Fatalf("node resources = cpu %q memory %q gpu %q", node.Data.CPU, node.Data.Memory, node.Data.GPU)
}
if node.Data.Image != "ccr.example/droboticflow-operator-act-policy-train:v1" {
t.Fatalf("node image = %q", node.Data.Image)
}
if node.Data.OperatorImageID != "ccr.example/droboticflow-operator-act-policy-train@sha256:abc123" {
t.Fatalf("node image id = %q", node.Data.OperatorImageID)
}
if got := strings.Join(node.Data.ContainerCommand, " "); got != "python /app/backend/operator-runner/main.py" {
t.Fatalf("container command = %q", got)
}
if got := strings.Join(node.Data.ContainerArgs, " "); got != "--strict" {
t.Fatalf("container args = %q", got)
}
if mode := hyperparamValue(node.Data.Hyperparams, "POC_ACCEPTANCE_MODE"); mode != "" {
t.Fatalf("POC_ACCEPTANCE_MODE must not be used for production GPU operators, got %q", mode)
}
if datasetPath := hyperparamValue(node.Data.Hyperparams, "DATASET_PATH"); datasetPath == "" {
t.Fatalf("DATASET_PATH should be configured for structured GPU acceptance")
}
}
func assertPocWorkflowEdgesSingleMainChain(t *testing.T, edges []domain.WorkflowEdge) {
t.Helper()
outgoing := map[string]int{}
incoming := map[string]int{}
nodes := map[string]struct{}{}
for _, edge := range edges {
if edge.Source == "" || edge.Target == "" {
t.Fatalf("edge has empty endpoint: %#v", edge)
}
nodes[edge.Source] = struct{}{}
nodes[edge.Target] = struct{}{}
outgoing[edge.Source]++
incoming[edge.Target]++
if outgoing[edge.Source] > 1 {
t.Fatalf("node %s has %d outgoing edges; workflow must be one main chain: %#v", edge.Source, outgoing[edge.Source], edges)
}
if incoming[edge.Target] > 1 {
t.Fatalf("node %s has %d incoming edges; workflow must be one main chain: %#v", edge.Target, incoming[edge.Target], edges)
}
}
if len(edges) == 0 {
return
}
starts := 0
ends := 0
for node := range nodes {
if incoming[node] == 0 {
starts++
}
if outgoing[node] == 0 {
ends++
}
}
if starts != 1 || ends != 1 {
t.Fatalf("workflow must have exactly one start and one end, got starts=%d ends=%d edges=%#v", starts, ends, edges)
}
}
func hyperparamValue(items []domain.HyperParam, key string) string {
for _, item := range items {
if item.Key == key {
return item.Value
}
}
return ""
}
// The acceptance preflight must reject invalid or missing fixtures before it creates any project or Run.
func TestValidatePocOperatorAcceptanceFixturesRejectsInvalidManifestBeforeCreation(t *testing.T) {
root := t.TempDir()
manifest := filepath.Join(root, "poc-operator-acceptance.json")
if err := os.WriteFile(manifest, []byte(".keep\\n"), 0o644); err != nil {
t.Fatal(err)
}
if _, _, err := validatePocOperatorAcceptanceFixtures(manifest, root); err == nil {
t.Fatal("expected invalid manifest to fail preflight")
}
}
func TestValidatePocOperatorAcceptanceFixturesRequiresRealPaths(t *testing.T) {
root := t.TempDir()
for _, directory := range []string{"xplatform", "lerobot", "rosbag"} {
if err := os.MkdirAll(filepath.Join(root, directory), 0o755); err != nil {
t.Fatal(err)
}
}
for _, file := range []string{"records.csv", "records.json", "quality-gate.json"} {
if err := os.WriteFile(filepath.Join(root, file), []byte("{}\\n"), 0o644); err != nil {
t.Fatal(err)
}
}
manifest := filepath.Join(root, "poc-operator-acceptance.json")
content := `{"fixtures":{"xplatform":"` + filepath.Join(root, "xplatform") + `","csv":"` + filepath.Join(root, "records.csv") + `","json":"` + filepath.Join(root, "records.json") + `","lerobot":"` + filepath.Join(root, "lerobot") + `","rosbag":"` + filepath.Join(root, "rosbag") + `","model":"` + filepath.Join(root, "quality-gate.json") + `"}}`
if err := os.WriteFile(manifest, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
fixtures, hash, err := validatePocOperatorAcceptanceFixtures(manifest, root)
if err != nil {
t.Fatalf("expected real fixture paths to pass: %v", err)
}
if fixtures.XPlatform != filepath.Join(root, "xplatform") || len(hash) != 64 {
t.Fatalf("unexpected preflight result: %#v hash=%q", fixtures, hash)
}
}
func TestValidatePocOperatorAcceptanceFixturesRejectsMissingPath(t *testing.T) {
root := t.TempDir()
manifest := filepath.Join(root, "poc-operator-acceptance.json")
content := `{"fixtures":{"xplatform":"` + filepath.Join(root, "missing") + `","csv":"` + filepath.Join(root, "records.csv") + `","json":"` + filepath.Join(root, "records.json") + `","lerobot":"` + filepath.Join(root, "lerobot") + `","rosbag":"` + filepath.Join(root, "rosbag") + `","model":"` + filepath.Join(root, "quality-gate.json") + `"}}`
if err := os.WriteFile(manifest, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
if _, _, err := validatePocOperatorAcceptanceFixtures(manifest, root); err == nil {
t.Fatal("expected missing fixture path to fail preflight")
}
}