forked from longtao.wu/droboticflow
513 lines
25 KiB
Go
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)
|
|
}
|
|
}
|