droboticflow/internal/api/fanyu_template_test.go
2026-08-25 04:17:45 +08:00

513 lines
25 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 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 {
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) != 23 {
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, "手部预标") || v57Headpose == nil || !strings.Contains(v57Headpose.Data.Label, "带渲染") {
t.Fatalf("v5.7 must present hand/head outputs as reviewed prelabels: 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 prelabels must enter human review: %#v", reviewEdges)
}
}