droboticflow/internal/api/fanyu_template_test.go

736 lines
36 KiB
Go

package api
import (
"context"
"strings"
"testing"
"droboticflow/internal/domain"
pluginregistry "droboticflow/internal/plugins"
"droboticflow/internal/store"
)
func fanyuTestNode(nodes []domain.WorkflowNode, id string) *domain.WorkflowNode {
for index := range nodes {
if nodes[index].ID == id {
return &nodes[index]
}
}
return nil
}
func fanyuTestHyperparam(node *domain.WorkflowNode, key string) string {
if node == nil {
return ""
}
for _, item := range node.Data.Hyperparams {
if item.Key == key {
return item.Value
}
}
return ""
}
func TestFanyuTemplateCleanupDoesNotRecreateLegacyTemplates(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
operators, err := builtinOperatorRecords("2026-09-06T00:00:00Z", "registry.example/runner:test")
if err != nil {
t.Fatal(err)
}
for _, operator := range operators {
if err := dataStore.UpsertOperator(ctx, operator); err != nil {
t.Fatal(err)
}
}
srv := &server{store: dataStore}
if err := srv.ensureFanyuDeliveryTemplate(ctx, "org-cleanup"); err != nil {
t.Fatal(err)
}
legacy := []string{fanyuDeliveryTemplateID, fanyuOrbbecDeliveryTemplateID, fanyuDeliveryTemplateV3ID,
fanyuDeliveryTemplateV4ID, fanyuDeliveryTemplateV5ID, fanyuDeliveryTemplateV54ID,
fanyuDeliveryTemplateV55ID, fanyuDeliveryTemplateV56ID, fanyuDeliveryTemplateV57ID}
for _, id := range legacy {
if deleted, err := dataStore.DeleteTemplate(ctx, id+"-org-cleanup"); err != nil || !deleted {
t.Fatalf("delete %s: deleted=%v err=%v", id, deleted, err)
}
}
for pass := 0; pass < 2; pass++ {
if err := srv.ensureFanyuDeliveryTemplate(ctx, "org-cleanup"); err != nil {
t.Fatal(err)
}
for _, id := range legacy {
if item, err := dataStore.GetTemplate(ctx, id+"-org-cleanup"); err != nil || item != nil {
t.Fatalf("legacy template recreated: %s err=%v", id, err)
}
}
current, err := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV58ID+"-org-cleanup")
if err != nil || current == nil || len(current.Nodes) != 10 || len(current.Edges) != 25 {
t.Fatalf("current template lost its standalone graph: %v", err)
}
}
}
func TestFanyuLegacyNodeDropsModernPortContractFields(t *testing.T) {
operator := domain.OperatorRecord{
ID: "operator-builtin-xplatform-dataset-index",
Inputs: []domain.PortDefinition{{
ID: "in-1", Name: "input", Type: domain.PortTypeJSON,
Container: domain.PortContainerDirectory, PayloadMode: domain.ArtifactTransferModeRef,
}},
Outputs: []domain.PortDefinition{{
ID: "out-1", Name: "dataset", Type: domain.PortTypeJSON,
Container: domain.PortContainerDataset, PayloadMode: domain.ArtifactTransferModeRef,
}},
}
node := fanyuNode("legacy", "legacy", operator, 0, 0)
for _, port := range append(node.Data.Inputs, node.Data.Outputs...) {
if port.Container != "" || port.PayloadMode != "" {
t.Fatalf("legacy port retained strict contract: %#v", port)
}
}
}
func TestEnsureFanyuDeliveryTemplatePublishesOrbbecV2WithoutMutatingV1(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-19T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatalf("upsert operator %s: %v", item.ID, err)
}
}
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-a"); err != nil {
t.Fatal(err)
}
v1, err := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateID+"-org-a")
if err != nil || v1 == nil || v1.Name != "01-右相机切分标注质检-v1" {
t.Fatalf("v1 template=%#v err=%v", v1, err)
}
v2, err := dataStore.GetTemplate(ctx, fanyuOrbbecDeliveryTemplateID+"-org-a")
if err != nil || v2 == nil {
t.Fatalf("v2 template=%#v err=%v", v2, err)
}
if v2.Name != "01-右相机切分标注质检-v2-Orbbec" || len(v2.Nodes) != 7 || len(v2.Edges) != 7 {
t.Fatalf("unexpected v2 template: %#v", v2)
}
if issues := validateWorkflowTopology(v2.Nodes, v2.Edges); len(issues) > 0 {
t.Fatalf("v2 topology issues: %#v", issues)
}
if fanyuTestNode(v2.Nodes, "fanyu-index") != nil || fanyuTestNode(v2.Nodes, "fanyu-filter") != nil {
t.Fatalf("v2 must not route Orbbec data through the X-platform index/filter: %#v", v2.Nodes)
}
normalize := fanyuTestNode(v2.Nodes, "fanyu-normalize")
if normalize == nil || normalize.Data.OperatorID != "operator-builtin-orbbec-data-normalize" {
t.Fatalf("missing Orbbec normalize node: %#v", normalize)
}
if got := fanyuTestHyperparam(normalize, "CAMERA_SIDE"); got != "right" {
t.Fatalf("CAMERA_SIDE=%q", got)
}
if got := fanyuTestHyperparam(normalize, "REQUIRE_STEREO"); got != "true" {
t.Fatalf("REQUIRE_STEREO=%q", got)
}
wilor := fanyuTestNode(v2.Nodes, "fanyu-wilor")
if wilor == nil || wilor.Data.OperatorID != "operator-builtin-wilor-hand-pose" {
t.Fatalf("missing WiLoR node: %#v", wilor)
}
if got := fanyuTestHyperparam(wilor, "INPUT_URL"); got != "" {
t.Fatalf("WiLoR INPUT_URL must use the upstream Orbbec video, got %q", got)
}
if got := fanyuTestHyperparam(wilor, "MEDIA_KIND"); got != "video" {
t.Fatalf("WiLoR MEDIA_KIND=%q", got)
}
release, err := dataStore.GetWorkflowRelease(ctx, "workflow-release-fanyu-orbbec-v2-org-a")
if err != nil || release == nil {
t.Fatalf("v2 release=%#v err=%v", release, err)
}
if release.Version != 2 || len(release.RequiredPluginIDs) != 2 || release.RequiredPluginIDs[0] != pluginregistry.HumanLoopCoreID || release.RequiredPluginIDs[1] != pluginregistry.AnnotationQAID {
t.Fatalf("unexpected v2 release: %#v", release)
}
}
func TestEnsureFanyuDeliveryTemplateCreatesLeftCameraV5AsFailClosedDraft(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-20T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatal(err)
}
}
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v5"); err != nil {
t.Fatal(err)
}
template, err := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV5ID+"-org-v5")
if err != nil || template == nil {
t.Fatalf("v5 template=%#v err=%v", template, err)
}
if got := fanyuTestHyperparam(fanyuTestNode(template.Nodes, "fanyu-v5-normalize"), "CAMERA_SIDE"); got != "left" {
t.Fatalf("v5 CAMERA_SIDE=%q", got)
}
if len(template.Nodes) != 6 || len(template.Edges) != 6 {
t.Fatalf("unexpected v5 topology nodes=%d edges=%d: %#v", len(template.Nodes), len(template.Edges), template)
}
if template.Kind != domain.WorkflowKindStandard || template.ScanConfig != nil {
t.Fatalf("directory-root v5 must not retain scan workflow state: kind=%s scanConfig=%#v", template.Kind, template.ScanConfig)
}
if fanyuTestNode(template.Nodes, "fanyu-v5-directory") == nil || fanyuTestNode(template.Nodes, "fanyu-v5-rough-cut") == nil {
t.Fatalf("v5 directory/Qwen rough-cut nodes missing: %#v", template.Nodes)
}
for _, obsoleteNodeID := range []string{"fanyu-v5-scan", "fanyu-v5-slice", "fanyu-v5-valid-event", "fanyu-v5-temporal", "fanyu-v5-handoff", "fanyu-v5-swift-export", "fanyu-v5-train"} {
if fanyuTestNode(template.Nodes, obsoleteNodeID) != nil {
t.Fatalf("v5 obsolete fixed-slice/temporal/training node %s must be absent", obsoleteNodeID)
}
}
if fanyuTestNode(template.Nodes, "fanyu-v5-headpose") != nil || fanyuTestNode(template.Nodes, "fanyu-v5-handpose") != nil || fanyuTestNode(template.Nodes, "fanyu-v5-options") != nil {
t.Fatalf("v5 pose stages are deferred and must not be present: %#v", template.Nodes)
}
if len(template.WorkflowInputs) != 1 || template.WorkflowInputs[0].ID != "sourceDirectory" || !template.WorkflowInputs[0].Required || template.WorkflowInputs[0].DefaultPayload != nil || len(template.WorkflowInputs[0].Bindings) != 1 || template.WorkflowInputs[0].Bindings[0].NodeID != "fanyu-v5-directory" {
t.Fatalf("v5 must expose one required directory ref input: %#v", template.WorkflowInputs)
}
packageNode := fanyuTestNode(template.Nodes, "fanyu-v5-package")
if packageNode == nil || fanyuTestHyperparam(packageNode, "REQUIRE_HEADPOSE") != "false" {
t.Fatalf("v5 pose-free package contract missing: %#v", packageNode)
}
for _, nodeID := range []string{"fanyu-v5-package", "fanyu-v5-human"} {
for _, input := range fanyuTestNode(template.Nodes, nodeID).Data.Inputs {
if (nodeID == "fanyu-v5-package" && input.ID != "in-1") || (nodeID == "fanyu-v5-human" && input.ID != "clips") {
t.Fatalf("v5 must expose only the direct aggregate-to-package contract on %s: %#v", nodeID, input)
}
}
}
roughCut := fanyuTestNode(template.Nodes, "fanyu-v5-rough-cut")
if fanyuTestHyperparam(roughCut, "TECHNICAL_BLOCK_SECONDS") != "10" || fanyuTestHyperparam(roughCut, "FRAMES_PER_TECHNICAL_BLOCK") != "18" || fanyuTestHyperparam(roughCut, "WINDOW_SECONDS") != "" || fanyuTestHyperparam(roughCut, "STRIDE_SECONDS") != "" || fanyuTestHyperparam(roughCut, "OVERLAP_SECONDS") != "" {
t.Fatalf("v5 rough-cut must use technical-only chunks without 200-second localization: %#v", roughCut)
}
human := fanyuTestNode(template.Nodes, "fanyu-v5-human")
if human == nil || fanyuTestHyperparam(human, "REQUIRE_PREPACKAGE_ACCEPTANCE") != "true" {
t.Fatalf("v5 aggregate acceptance gate missing: %#v", human)
}
if release, releaseErr := dataStore.GetWorkflowRelease(ctx, "workflow-release-fanyu-v5-org-v5"); releaseErr != nil || release != nil {
t.Fatalf("draft operators/model preconditions must not publish v5 release: %#v err=%v", release, releaseErr)
}
tpl, templateErr := dataStore.GetAnnotationTemplate(ctx, "tpl-fanyu-convenience-store-v5-org-v5")
if templateErr != nil || tpl == nil || !domain.IsFanyuV5FourStageHumanLoop(tpl.HumanStages) ||
tpl.HumanStages[1].RejectTargets[0] != domain.FanyuV5StageCutAdjustment ||
tpl.HumanStages[3].RejectTargets[0] != domain.FanyuV5StageSemanticAnnotation ||
len(tpl.HumanStages[3].RejectTargets) != 2 || tpl.HumanStages[3].RejectTargets[1] != domain.FanyuV5StageCutAdjustment {
t.Fatalf("unexpected v5 human stages: %#v err=%v", tpl, templateErr)
}
}
func TestEnsureFanyuDeliveryTemplateCreatesMultiportV54WithoutMutatingV5(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-22T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatal(err)
}
}
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v54"); err != nil {
t.Fatal(err)
}
template, err := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV54ID+"-org-v54")
if err != nil || template == nil {
t.Fatalf("v5.4 template=%#v err=%v", template, err)
}
if template.DefinitionVersion != 4 || template.SupersedesTemplateID != fanyuDeliveryTemplateV5ID+"-org-v54" || len(template.Nodes) != 6 || len(template.Edges) != 10 {
t.Fatalf("unexpected v5.4 definition: %#v", template)
}
if issues := validateWorkflowTopology(template.Nodes, template.Edges); len(issues) > 0 {
t.Fatalf("v5.4 topology issues: %#v", issues)
}
for _, unwanted := range []string{"fanyu-v54-headpose", "fanyu-v54-handpose", "fanyu-v54-train"} {
if fanyuTestNode(template.Nodes, unwanted) != nil {
t.Fatalf("v5.4 must exclude %s", unwanted)
}
}
normalize := fanyuTestNode(template.Nodes, "fanyu-v54-normalize")
if normalize == nil || len(normalize.Data.Outputs) == 0 || normalize.Data.Outputs[0].Container == "" {
t.Fatalf("v5.4 must retain explicit port contracts: %#v", normalize)
}
packageNode := fanyuTestNode(template.Nodes, "fanyu-v54-package")
if packageNode == nil || len(packageNode.Data.Inputs) != 2 || packageNode.Data.Inputs[0].ID != "approvedVideos" || packageNode.Data.Inputs[1].ID != "annotations" {
t.Fatalf("v5.4 package inputs=%#v", packageNode)
}
if release, releaseErr := dataStore.GetWorkflowRelease(ctx, "workflow-release-fanyu-v5-4-org-v54"); releaseErr != nil || release != nil {
t.Fatalf("unpublished builtin images must keep v5.4 release fail-closed: %#v err=%v", release, releaseErr)
}
}
func TestEnsureFanyuAnnotationTemplateUpgradesStaleV5HumanStages(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
organizationID := "org-v5-stale-human-stages"
template := domain.DefaultConvenienceStoreAnnotationTemplate(organizationID, "project-preserved", 5)
template.HumanStages = []domain.HumanStageDefinition{
{ID: "annotation_combined", Label: "旧合并标注", Kind: domain.HumanStageAnnotation, RequiredRole: "annotator"},
{ID: "quality_review", Label: "旧统一质检", Kind: domain.HumanStageReview, RequiredRole: "quality_reviewer", RejectTargets: []string{"annotation_combined"}},
}
template.PublishedAt = "2026-08-01T00:00:00Z"
if err := dataStore.UpsertAnnotationTemplate(ctx, template); err != nil {
t.Fatal(err)
}
server := &server{store: dataStore}
if err := server.ensureFanyuConvenienceStoreAnnotationTemplates(ctx, organizationID); err != nil {
t.Fatal(err)
}
updated, err := dataStore.GetAnnotationTemplate(ctx, template.ID)
if err != nil || updated == nil || !domain.IsFanyuV5FourStageHumanLoop(updated.HumanStages) {
t.Fatalf("stale v5 stages were not upgraded: template=%#v err=%v", updated, err)
}
if updated.ProjectID != "project-preserved" || updated.PublishedAt != template.PublishedAt || len(updated.Labels) != len(template.Labels) {
t.Fatalf("v5 stage upgrade must preserve business metadata: %#v", updated)
}
}
func TestEnsureFanyuV5RefreshesEditableTemplateWithoutMutatingExistingRelease(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-21T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatal(err)
}
}
organizationID := "org-v5-refresh"
templateID := fanyuDeliveryTemplateV5ID + "-" + organizationID
releaseID := "workflow-release-fanyu-v5-" + organizationID
if err := dataStore.UpsertTemplate(ctx, domain.TemplateRecord{ID: templateID, OrganizationID: organizationID, Name: "stale v5", Type: domain.WorkflowTypeBatch, Kind: domain.WorkflowKindScan, Nodes: []domain.WorkflowNode{{ID: "stale"}}}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertWorkflowRelease(ctx, domain.WorkflowReleaseRecord{ID: releaseID, OrganizationID: organizationID, TemplateID: templateID, Version: 5, Name: "immutable old release", Type: domain.WorkflowTypeBatch, Kind: domain.WorkflowKindScan}); err != nil {
t.Fatal(err)
}
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplateV5(ctx, organizationID); err != nil {
t.Fatal(err)
}
template, err := dataStore.GetTemplate(ctx, templateID)
if err != nil || template == nil || template.Kind != domain.WorkflowKindStandard || len(template.Nodes) != 6 || fanyuTestNode(template.Nodes, "fanyu-v5-rough-cut") == nil {
t.Fatalf("editable template was not refreshed: template=%#v err=%v", template, err)
}
release, err := dataStore.GetWorkflowRelease(ctx, releaseID)
if err != nil || release == nil || release.Name != "immutable old release" || release.Kind != domain.WorkflowKindScan {
t.Fatalf("existing release must remain immutable: release=%#v err=%v", release, err)
}
}
func TestFanyuV3StaysDraftUntilRealHeadposeServiceAndDigestsAreConfigured(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-19T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatalf("upsert operator %s: %v", item.ID, err)
}
}
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v3"); err != nil {
t.Fatal(err)
}
templateID := fanyuDeliveryTemplateV3ID + "-org-v3"
template, err := dataStore.GetTemplate(ctx, templateID)
if err != nil || template == nil {
t.Fatalf("v3 template=%#v err=%v", template, err)
}
if len(template.Nodes) != 8 || len(template.Edges) != 9 || len(template.WorkflowInputs) != 1 {
t.Fatalf("unexpected v3 topology: %#v", template)
}
for _, node := range template.Nodes {
if node.Data.OperatorID == "operator-builtin-video-quality" {
t.Fatalf("v3 must not contain a dedicated video-quality node: %#v", node)
}
}
input := template.WorkflowInputs[0]
if input.ID != "deliveryOptions" || input.DefaultPayload == nil || input.DefaultPayload.Mode != domain.ArtifactTransferModeInline {
t.Fatalf("delivery options input=%#v", input)
}
if release, releaseErr := dataStore.GetWorkflowRelease(ctx, "workflow-release-fanyu-v3-org-v3"); releaseErr != nil || release != nil {
t.Fatalf("v3 release must be blocked without real Headpose evidence: release=%#v err=%v", release, releaseErr)
}
headpose, err := dataStore.GetOperator(ctx, "operator-builtin-head-pose")
if err != nil || headpose == nil {
t.Fatalf("headpose operator=%#v err=%v", headpose, err)
}
digest := "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
headpose.ImageID = "registry.example/droboticflow-operator-head-pose@" + digest
if err := dataStore.UpsertOperator(ctx, *headpose); err != nil {
t.Fatal(err)
}
t.Setenv("FANYU_HEADPOSE_API_BASE_URL", "http://headpose.droboticflow.svc.cluster.local")
t.Setenv("FANYU_HEADPOSE_SERVICE_IMAGE_ID", "registry.example/6drepnet-service@"+digest)
t.Setenv("FANYU_HEADPOSE_MODEL_SHA256", digest)
t.Setenv("FANYU_HEADPOSE_LICENSE_ID", "MIT")
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v3"); err != nil {
t.Fatal(err)
}
release, err := dataStore.GetWorkflowRelease(ctx, "workflow-release-fanyu-v3-org-v3")
if err != nil || release == nil {
t.Fatalf("v3 release=%#v err=%v", release, err)
}
if release.Version != 3 || len(release.WorkflowInputs) != 1 || fanyuTestHyperparam(fanyuTestNode(release.Nodes, "fanyu-v3-headpose"), "HEADPOSE_SERVICE_IMAGE_ID") == "" {
t.Fatalf("unexpected v3 release: %#v", release)
}
}
func TestEnsureFanyuDeliveryTemplateV55InsertsUndistortAndStaysFailClosed(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-23T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatal(err)
}
}
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v55"); err != nil {
t.Fatal(err)
}
template, templateErr := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV55ID+"-org-v55")
if templateErr != nil || template == nil {
t.Fatalf("v5.5 template=%#v err=%v", template, templateErr)
}
if template.DefinitionVersion != 5 || template.SupersedesTemplateID != fanyuDeliveryTemplateV54ID+"-org-v55" {
t.Fatalf("unexpected v5.5 versioning: %#v", template)
}
if len(template.Nodes) != 7 || len(template.Edges) != 13 {
t.Fatalf("v5.5 must insert undistort node: nodes=%d edges=%d", len(template.Nodes), len(template.Edges))
}
if issues := validateWorkflowTopology(template.Nodes, template.Edges); len(issues) > 0 {
t.Fatalf("v5.5 topology issues: %#v", issues)
}
undistort := fanyuTestNode(template.Nodes, "fanyu-v55-undistort")
if undistort == nil || fanyuTestHyperparam(undistort, "REQUIRE_CALIBRATION") != "true" {
t.Fatalf("v5.5 undistort must be fail-closed on calibrations: %#v", undistort)
}
roughCut := fanyuTestNode(template.Nodes, "fanyu-v55-rough-cut")
if roughCut == nil {
t.Fatal("v5.5 qwen rough cut node is missing")
}
if longRunning, ok := roughCut.Data.RuntimeContract["longRunning"].(bool); !ok || !longRunning {
t.Fatalf("v5.5 qwen rough cut must use the long-running job window: %#v", roughCut)
}
hasCalibrationEdge, hasRectifiedEdge, hasAudioEdge := false, false, false
for _, edge := range template.Edges {
if edge.Source == "fanyu-v55-normalize" && edge.SourceHandle == "calibrations" && edge.Target == "fanyu-v55-undistort" && edge.TargetHandle == "calibrations" {
hasCalibrationEdge = true
}
if edge.Source == "fanyu-v55-undistort" && edge.SourceHandle == "leftRectifiedVideos" && edge.Target == "fanyu-v55-face-blur" && edge.TargetHandle == "videos" {
hasRectifiedEdge = true
}
if edge.Source == "fanyu-v55-normalize" && edge.SourceHandle == "audio" && edge.Target == "fanyu-v55-face-blur" && edge.TargetHandle == "audio" {
hasAudioEdge = true
}
}
if !hasCalibrationEdge || !hasRectifiedEdge || !hasAudioEdge {
t.Fatalf("v5.5 must route calibrations→undistort, rectifiedVideos→face-blur and normalize.audio→face-blur")
}
faceBlur := fanyuTestNode(template.Nodes, "fanyu-v55-face-blur")
if faceBlur == nil || fanyuTestHyperparam(faceBlur, "DETECTION_METHOD") != "yunet" || fanyuTestHyperparam(faceBlur, "REQUIRE_PTS") != "true" {
t.Fatalf("v5.5 face anonymization must use fixed YuNet and require PTS: %#v", faceBlur)
}
if release, releaseErr := dataStore.GetWorkflowRelease(ctx, "workflow-release-fanyu-v5-5-org-v55"); releaseErr != nil || release != nil {
t.Fatalf("draft undistort operator must keep v5.5 release fail-closed: %#v err=%v", release, releaseErr)
}
}
func TestEnsureFanyuDeliveryTemplateV56BuildsStereoCropAndPoseTopology(t *testing.T) {
ctx := context.Background()
dataStore := store.NewMemoryStore()
items, err := builtinOperatorRecords("2026-08-24T00:00:00Z", "registry.example/droboticflow-operator-runner:test")
if err != nil {
t.Fatal(err)
}
for _, item := range items {
item.Inputs = domain.NormalizePortDefinitions(item.Inputs)
item.Outputs = domain.NormalizePortDefinitions(item.Outputs)
if err := dataStore.UpsertOperator(ctx, item); err != nil {
t.Fatal(err)
}
}
t.Setenv("FANYU_HEADPOSE_API_BASE_URL", "http://droboticflow-headpose:8080")
t.Setenv("FANYU_HEADPOSE_SERVICE_IMAGE_ID", "registry.example/headpose@sha256:"+strings.Repeat("a", 64))
t.Setenv("FANYU_HEADPOSE_MODEL_SHA256", "sha256:"+strings.Repeat("b", 64))
t.Setenv("FANYU_HEADPOSE_LICENSE_ID", "MIT")
server := &server{store: dataStore}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v56"); err != nil {
t.Fatal(err)
}
template, templateErr := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV56ID+"-org-v56")
if templateErr != nil || template == nil {
t.Fatalf("v5.6 template=%#v err=%v", template, templateErr)
}
if template.DefinitionVersion != 6 || template.SupersedesTemplateID != fanyuDeliveryTemplateV55ID+"-org-v56" {
t.Fatalf("unexpected v5.6 versioning: %#v", template)
}
if len(template.Nodes) != 10 || len(template.Edges) != 21 {
t.Fatalf("v5.6 topology must contain stereo/pose branches: nodes=%d edges=%d", len(template.Nodes), len(template.Edges))
}
if issues := validateWorkflowTopology(template.Nodes, template.Edges); len(issues) > 0 {
t.Fatalf("v5.6 topology issues: %#v", issues)
}
undistort := fanyuTestNode(template.Nodes, "fanyu-v56-undistort")
normalize := fanyuTestNode(template.Nodes, "fanyu-v56-normalize")
packageNode := fanyuTestNode(template.Nodes, "fanyu-v56-package")
headpose := fanyuTestNode(template.Nodes, "fanyu-v56-headpose")
handpose := fanyuTestNode(template.Nodes, "fanyu-v56-handpose")
if undistort == nil || fanyuTestHyperparam(undistort, "REQUIRE_STEREO") != "true" {
t.Fatalf("v5.6 undistort must require stereo inputs: %#v", undistort)
}
if normalize == nil || fanyuTestHyperparam(normalize, "CAMERA_SIDE") != "both" || fanyuTestHyperparam(normalize, "REQUIRE_STEREO") != "true" {
t.Fatalf("v5.6 normalize must emit both camera sides: %#v", normalize)
}
if packageNode == nil || fanyuTestHyperparam(packageNode, "REQUIRE_STEREO_DELIVERY") != "true" || fanyuTestHyperparam(packageNode, "REQUIRE_HEADPOSE") != "true" || fanyuTestHyperparam(packageNode, "REQUIRE_HANDPOSE") != "true" || fanyuTestHyperparam(packageNode, "POSE_FREE") != "false" {
t.Fatalf("v5.6 package must require stereo and both poses: %#v", packageNode)
}
if headpose == nil || headpose.Data.OperatorID != "operator-builtin-head-pose" || fanyuTestHyperparam(headpose, "HEADPOSE_MODEL") != "6DRepNet" {
t.Fatalf("v5.6 headpose node is invalid: %#v", headpose)
}
if handpose == nil || handpose.Data.OperatorID != "operator-builtin-wilor-hand-pose" || fanyuTestHyperparam(handpose, "MEDIA_KIND") != "video" || fanyuTestHyperparam(handpose, "INPUT_URL") != "" || fanyuTestHyperparam(handpose, "MAX_FRAMES") != "120" || fanyuTestHyperparam(handpose, "VIDEO_CHUNK_FRAMES") != "119" || fanyuTestHyperparam(handpose, "REQUIRE_FULL_VIDEO_COVERAGE") != "true" {
t.Fatalf("v5.6 handpose node is invalid: %#v", handpose)
}
requiredEdges := map[string]bool{
"right-normalize-undistort": false,
"right-undistort-blur": false,
"left-rectified-pts": false,
"right-rectified-pts": false,
"right-blur-package": false,
"headpose-package": false,
"handpose-package": false,
}
for _, edge := range template.Edges {
switch {
case edge.Source == "fanyu-v56-normalize" && edge.SourceHandle == "rightVideos" && edge.Target == "fanyu-v56-undistort":
requiredEdges["right-normalize-undistort"] = true
case edge.Source == "fanyu-v56-undistort" && edge.SourceHandle == "rightRectifiedVideos" && edge.Target == "fanyu-v56-right-blur":
requiredEdges["right-undistort-blur"] = true
case edge.Source == "fanyu-v56-undistort" && edge.SourceHandle == "leftRectifiedTimestamps" && edge.Target == "fanyu-v56-left-blur":
requiredEdges["left-rectified-pts"] = true
case edge.Source == "fanyu-v56-undistort" && edge.SourceHandle == "rightRectifiedTimestamps" && edge.Target == "fanyu-v56-right-blur":
requiredEdges["right-rectified-pts"] = true
case edge.Source == "fanyu-v56-right-blur" && edge.SourceHandle == "blurredVideos" && edge.Target == "fanyu-v56-package" && edge.TargetHandle == "rightVideos":
requiredEdges["right-blur-package"] = true
case edge.Source == "fanyu-v56-headpose" && edge.Target == "fanyu-v56-package" && edge.TargetHandle == "headpose":
requiredEdges["headpose-package"] = true
case edge.Source == "fanyu-v56-handpose" && edge.Target == "fanyu-v56-package" && edge.TargetHandle == "handpose":
requiredEdges["handpose-package"] = true
}
}
for name, found := range requiredEdges {
if !found {
t.Fatalf("v5.6 missing edge %s", name)
}
}
v57, v57Err := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV57ID+"-org-v56")
if v57Err != nil || v57 == nil {
t.Fatalf("v5.7 template=%#v err=%v", v57, v57Err)
}
if v57.DefinitionVersion != 7 || v57.SupersedesTemplateID != fanyuDeliveryTemplateV56ID+"-org-v56" || len(v57.Nodes) != 10 || len(v57.Edges) != 22 {
t.Fatalf("unexpected v5.7 prelabel topology: %#v", v57)
}
v57HandPrelabel := fanyuTestNode(v57.Nodes, "fanyu-v56-handpose")
v57Headpose := fanyuTestNode(v57.Nodes, "fanyu-v56-headpose")
if v57HandPrelabel == nil || !strings.Contains(v57HandPrelabel.Data.Label, "3D HandPose") || v57Headpose == nil || !strings.Contains(v57Headpose.Data.Label, "带渲染") {
t.Fatalf("v5.7 must present automatic HandPose and rendered HeadPose: hand=%#v head=%#v", v57HandPrelabel, v57Headpose)
}
reviewEdges := map[string]bool{"head": false, "hand": false}
for _, edge := range v57.Edges {
if edge.Source == "fanyu-v56-headpose" && edge.Target == "fanyu-v56-human" && edge.TargetHandle == "headpose" {
reviewEdges["head"] = true
}
if edge.Source == "fanyu-v56-handpose" && edge.Target == "fanyu-v56-human" && edge.TargetHandle == "handpose" {
reviewEdges["hand"] = true
}
}
if !reviewEdges["head"] || reviewEdges["hand"] {
t.Fatalf("v5.7 must review HeadPose but bypass human review for HandPose: %#v", reviewEdges)
}
v58, v58Err := dataStore.GetTemplate(ctx, fanyuDeliveryTemplateV58ID+"-org-v56")
if v58Err != nil || v58 == nil {
t.Fatalf("v5.8 template=%#v err=%v", v58, v58Err)
}
if v58.DefinitionVersion != 8 || v58.SupersedesTemplateID != fanyuDeliveryTemplateV57ID+"-org-v56" || len(v58.Nodes) != 10 || len(v58.Edges) != 25 {
t.Fatalf("unexpected v5.8 synchronized topology: %#v", v58)
}
v58Package := fanyuTestNode(v58.Nodes, "fanyu-v56-package")
v58Human := fanyuTestNode(v58.Nodes, "fanyu-v56-human")
v58Qwen := fanyuTestNode(v58.Nodes, "fanyu-v56-rough-cut")
v58Handpose := fanyuTestNode(v58.Nodes, "fanyu-v56-handpose")
v58LeftBlur := fanyuTestNode(v58.Nodes, "fanyu-v56-left-blur")
v58RightBlur := fanyuTestNode(v58.Nodes, "fanyu-v56-right-blur")
if v58Package == nil || fanyuTestHyperparam(v58Package, "SYNCHRONIZED_SIDECARS") != "true" || fanyuTestHyperparam(v58Package, "ALLOW_POSE_EXCLUSION") != "true" {
t.Fatalf("v5.8 package must enable synchronized sidecars and pose exclusion: %#v", v58Package)
}
if v58Package.Data.Image != fanyuV58PackageImage || v58Package.Data.OperatorImageID != fanyuV58PackageImageID {
t.Fatalf("v5.8 package must use the Fanyu full-coverage release: %#v", v58Package.Data)
}
if fanyuTestHyperparam(v58Package, "PIN_OPERATOR_IMAGE") != "true" {
t.Fatalf("v5.8 package must preserve its Fanyu environment image pin: %#v", v58Package.Data.Hyperparams)
}
requiredV58Inputs := map[string]bool{"acceptedSliceDirectory": false, "acceptanceSummary": false, "headpose": false, "handpose": false, "calibrations": false}
for _, input := range v58Package.Data.Inputs {
if _, required := requiredV58Inputs[input.ID]; required {
requiredV58Inputs[input.ID] = true
if input.ID != "headpose" && input.ID != "handpose" && !input.Required {
t.Fatalf("v5.8 package input %s must be required", input.ID)
}
}
}
for name, found := range requiredV58Inputs {
if !found {
t.Fatalf("v5.8 package node is missing synchronized input port %s", name)
}
}
if v58Human == nil || fanyuTestHyperparam(v58Human, "ANNOTATION_TEMPLATE_ID") != "tpl-fanyu-convenience-store-v6-org-v56" {
t.Fatalf("v5.8 human node must use the three-role annotation template: %#v", v58Human)
}
requiredV58HumanInputs := map[string]bool{"fullLeftVideos": false, "fullRightVideos": false, "leftTimestamps": false, "rightTimestamps": false, "imu": false, "roughCutWindows": false, "headposeEvidence": false, "handposeEvidence": false}
for _, input := range v58Human.Data.Inputs {
if _, required := requiredV58HumanInputs[input.ID]; required {
requiredV58HumanInputs[input.ID] = true
if input.ID != "headposeEvidence" && input.ID != "handposeEvidence" && !input.Required {
t.Fatalf("v5.8 human input %s must be required", input.ID)
}
}
}
for name, found := range requiredV58HumanInputs {
if !found {
t.Fatalf("v5.8 human node is missing evidence input %s", name)
}
}
for _, node := range []*domain.WorkflowNode{fanyuTestNode(v58.Nodes, "fanyu-v56-headpose"), fanyuTestNode(v58.Nodes, "fanyu-v56-handpose")} {
if node == nil || len(node.Data.Outputs) != 1 || node.Data.Outputs[0].ID != "out-1" || node.Data.Outputs[0].Type != domain.PortTypeFile || node.Data.Outputs[0].Container != domain.PortContainerCollection || node.Data.Outputs[0].Role != "evidence" {
t.Fatalf("v5.8 pose output must be a mixed evidence collection: %#v", node)
}
}
for _, portID := range []string{"headposeEvidence", "handposeEvidence"} {
found := false
for _, input := range v58Human.Data.Inputs {
if input.ID == portID {
found = input.Type == domain.PortTypeFile && input.Container == domain.PortContainerCollection && input.Role == "evidence"
}
}
if !found {
t.Fatalf("v5.8 human pose port %s must be a mixed evidence collection: %#v", portID, v58Human.Data.Inputs)
}
}
if v58Qwen == nil || len(v58Qwen.Data.Outputs) != 1 || v58Qwen.Data.Outputs[0].ID != "roughCutWindows" || v58Qwen.Data.Outputs[0].PayloadMode != domain.ArtifactTransferModeInline || v58Qwen.Data.Outputs[0].Transmission != "bus" {
t.Fatalf("v5.8 Qwen must emit only roughCutWindows: %#v", v58Qwen)
}
if fanyuTestHyperparam(v58Qwen, "TECHNICAL_BLOCK_SECONDS") != "5" || fanyuTestHyperparam(v58Qwen, "FRAMES_PER_TECHNICAL_BLOCK") != "8" || fanyuTestHyperparam(v58Qwen, "PIN_OPERATOR_IMAGE") != "true" {
t.Fatalf("v5.8 Qwen must use dense five-second sampling for multi-action coverage: %#v", v58Qwen.Data.Hyperparams)
}
if v58Qwen.Data.Image != fanyuV58QwenImage || v58Qwen.Data.OperatorImageID != fanyuV58QwenImageID {
t.Fatalf("v5.8 Qwen must use the Fanyu full-coverage release: %#v", v58Qwen.Data)
}
requiredV58Outputs := map[string]bool{"deliveryDirectory": false, "deliveryManifest": false, "deliverySummary": false}
for _, output := range v58Package.Data.Outputs {
if _, required := requiredV58Outputs[output.ID]; required {
requiredV58Outputs[output.ID] = true
}
}
for name, found := range requiredV58Outputs {
if !found {
t.Fatalf("v5.8 package node is missing delivery output %s", name)
}
}
for _, portID := range []string{"headpose", "handpose"} {
found := false
for _, input := range v58Package.Data.Inputs {
if input.ID == portID {
found = input.Type == domain.PortTypeFile && input.Container == domain.PortContainerCollection && input.Role == "evidence"
}
}
if !found {
t.Fatalf("v5.8 package pose port %s must be a mixed evidence collection: %#v", portID, v58Package.Data.Inputs)
}
}
if v58Handpose == nil || fanyuTestHyperparam(v58Handpose, "WILOR_API_BASE_URL") != "http://droboticflow-wilor:8080" || fanyuTestHyperparam(v58Handpose, "INPUT_URL") != "" {
t.Fatalf("v5.8 HandPose must use the in-cluster WiLoR service and upstream media: %#v", v58Handpose)
}
if v58LeftBlur == nil || v58RightBlur == nil || fanyuTestHyperparam(v58LeftBlur, "PRESERVE_AUDIO") != "false" || fanyuTestHyperparam(v58RightBlur, "PRESERVE_AUDIO") != "false" {
t.Fatalf("v5.8 face blur must not require or preserve audio: left=%#v right=%#v", v58LeftBlur, v58RightBlur)
}
for _, blurNode := range []*domain.WorkflowNode{v58LeftBlur, v58RightBlur} {
if fanyuTestHyperparam(blurNode, "DIAGNOSTIC_FRAME_LIMIT") != "12" || fanyuTestHyperparam(blurNode, "PIN_OPERATOR_IMAGE") != "true" {
t.Fatalf("v5.8 face blur must emit pinned privacy-safe diagnostics: %#v", blurNode.Data.Hyperparams)
}
requiredOutputs := map[string]bool{"blurredVideos": false, "detectionSummary": false, "diagnosticFrames": false}
for _, output := range blurNode.Data.Outputs {
if _, required := requiredOutputs[output.ID]; required {
requiredOutputs[output.ID] = true
}
}
for outputID, found := range requiredOutputs {
if !found {
t.Fatalf("v5.8 face blur missing %s output: %#v", outputID, blurNode.Data.Outputs)
}
}
}
requiredV58Edges := map[string]bool{"handposeAcceptance": false, "qwenWindows": false, "acceptedDirectory": false, "acceptanceSummary": false, "calibrations": false, "headposePackage": false, "handposePackage": false}
for _, edge := range v58.Edges {
if edge.Source == "fanyu-v56-handpose" && edge.SourceHandle == "out-1" && edge.Target == "fanyu-v56-human" && edge.TargetHandle == "handposeEvidence" {
requiredV58Edges["handposeAcceptance"] = true
}
if edge.Source == "fanyu-v56-rough-cut" && edge.SourceHandle == "roughCutWindows" && edge.Target == "fanyu-v56-human" && edge.TargetHandle == "roughCutWindows" {
requiredV58Edges["qwenWindows"] = true
}
if edge.Target == "fanyu-v56-package" {
switch edge.TargetHandle {
case "acceptedSliceDirectory":
requiredV58Edges["acceptedDirectory"] = edge.Source == "fanyu-v56-human"
case "acceptanceSummary":
requiredV58Edges["acceptanceSummary"] = edge.Source == "fanyu-v56-human"
case "calibrations":
requiredV58Edges["calibrations"] = edge.Source == "fanyu-v56-normalize"
case "headpose":
requiredV58Edges["headposePackage"] = edge.Source == "fanyu-v56-headpose"
case "handpose":
requiredV58Edges["handposePackage"] = edge.Source == "fanyu-v56-handpose"
}
}
}
for name, found := range requiredV58Edges {
if !found {
t.Fatalf("v5.8 missing synchronized package edge %s", name)
}
}
v6Annotation, annotationErr := dataStore.GetAnnotationTemplate(ctx, "tpl-fanyu-convenience-store-v6-org-v56")
if annotationErr != nil || v6Annotation == nil || !domain.IsFanyuV58ThreeRoleHumanLoop(v6Annotation.HumanStages) {
t.Fatalf("v5.8 annotation template=%#v err=%v", v6Annotation, annotationErr)
}
if err := server.ensureFanyuDeliveryTemplate(ctx, "org-v56"); err != nil {
t.Fatalf("repeat v5.8 reconciliation: %v", err)
}
v6Annotation, annotationErr = dataStore.GetAnnotationTemplate(ctx, "tpl-fanyu-convenience-store-v6-org-v56")
if annotationErr != nil || v6Annotation == nil || !domain.IsFanyuV58ThreeRoleHumanLoop(v6Annotation.HumanStages) {
t.Fatalf("repeat reconciliation must not toggle v6 back to four stages: %#v err=%v", v6Annotation, annotationErr)
}
}