forked from longtao.wu/droboticflow
736 lines
36 KiB
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)
|
|
}
|
|
}
|