package api import ( "context" "encoding/json" "math" "os" "os/exec" "path/filepath" "testing" "droboticflow/internal/domain" "droboticflow/internal/store" ) func writeMaterializationFixtureVideo(t *testing.T, path string) { t.Helper() if _, err := exec.LookPath("ffmpeg"); err != nil { t.Skip("ffmpeg is required") } command := exec.Command("ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i", "color=c=black:s=64x64:r=4:d=1", "-c:v", "libx264", "-pix_fmt", "yuv420p", path) if output, err := command.CombinedOutput(); err != nil { t.Fatalf("create fixture video: %v %s", err, output) } } func TestMaterializeCombinedSliceSubmissionCreatesStereoPTSImuAndTimestampedAnnotation(t *testing.T) { ctx := context.Background() workspace := t.TempDir() fixtureRoot := filepath.Join(workspace, "fixtures") if err := os.MkdirAll(fixtureRoot, 0o755); err != nil { t.Fatal(err) } leftVideo, rightVideo := filepath.Join(fixtureRoot, "capture_left.mp4"), filepath.Join(fixtureRoot, "capture_right.mp4") writeMaterializationFixtureVideo(t, leftVideo) writeMaterializationFixtureVideo(t, rightVideo) leftPTS, rightPTS := filepath.Join(fixtureRoot, "capture_left_pts.csv"), filepath.Join(fixtureRoot, "capture_right_pts.csv") pts := "frame_index,timestamp_us\n0,1000000\n1,1250000\n2,1500000\n3,1750000\n" if err := os.WriteFile(leftPTS, []byte(pts), 0o644); err != nil { t.Fatal(err) } if err := os.WriteFile(rightPTS, []byte(pts), 0o644); err != nil { t.Fatal(err) } imuPath := filepath.Join(fixtureRoot, "capture_imu.csv") imu := "timestamp_us,x,y,z,type\n1000000,0,0,9.8,accel\n1000000,0,0,0,gyro\n1250000,0,0,9.8,accel\n1250000,0,0,0,gyro\n1500000,0,0,9.8,accel\n1500000,0,0,0,gyro\n1750000,0,0,9.8,accel\n1750000,0,0,0,gyro\n" if err := os.WriteFile(imuPath, []byte(imu), 0o644); err != nil { t.Fatal(err) } artifact := func(id, name, path string, typ domain.PortType) domain.ExecutionArtifact { return domain.ExecutionArtifact{ID: id, Name: name, Path: path, Type: typ, Data: map[string]any{"collectionId": "capture"}} } leftArtifact := artifact("left-video", "capture_left.mp4", leftVideo, domain.PortTypeVideo) rightArtifact := artifact("right-video", "capture_right.mp4", rightVideo, domain.PortTypeVideo) leftPTSArtifact := artifact("left-pts", "capture_left_pts.csv", leftPTS, domain.PortTypeFile) rightPTSArtifact := artifact("right-pts", "capture_right_pts.csv", rightPTS, domain.PortTypeFile) imuArtifact := artifact("imu", "capture_imu.csv", imuPath, domain.PortTypeFile) run := domain.RunRecord{ ID: "run-materialize", OrganizationID: domain.DefaultOrganizationID, ProjectID: "project", WorkflowID: "workflow", Status: domain.RunStatusWaitingForHuman, NodeExecutions: []domain.NodeExecutionRecord{{ NodeID: "human", Status: domain.NodeExecutionStatusWaitingForHuman, InputArtifacts: []domain.ExecutionArtifact{leftArtifact, rightArtifact, leftPTSArtifact, rightPTSArtifact, imuArtifact}, InputBindings: []domain.NodeInputBinding{ {TargetPortID: "fullLeftVideos", Artifacts: []domain.ExecutionArtifact{leftArtifact}}, {TargetPortID: "fullRightVideos", Artifacts: []domain.ExecutionArtifact{rightArtifact}}, {TargetPortID: "leftTimestamps", Artifacts: []domain.ExecutionArtifact{leftPTSArtifact}}, {TargetPortID: "rightTimestamps", Artifacts: []domain.ExecutionArtifact{rightPTSArtifact}}, {TargetPortID: "imu", Artifacts: []domain.ExecutionArtifact{imuArtifact}}, }, }}, } dataStore := store.NewMemoryStore() if err := dataStore.UpsertRun(ctx, run); err != nil { t.Fatal(err) } server := &server{store: dataStore, workspaceMountPath: workspace} task := domain.AnnotationTaskRecord{ID: "task", OrganizationID: domain.DefaultOrganizationID, ProjectID: "project", WorkflowID: "workflow", RunID: run.ID, NodeID: "human", ArtifactID: leftArtifact.ID, ClipStart: 0, ClipEnd: 1, SourceIsFullVideo: true, SourceDurationSeconds: 1} item := domain.HumanItemRecord{ID: "item", OrganizationID: domain.DefaultOrganizationID, RunID: run.ID, GateNodeID: "human", Subject: domain.HumanSubjectRef{ItemKey: "capture", Payload: map[string]any{}}} timeline, timelineErr := server.annotationFrameTimelineForTask(ctx, task, "left") if timelineErr != nil { t.Fatal(timelineErr) } if timeline["boundaryContract"] != "hardware-frame-v1" || timeline["rangeStartSecond"] != float64(0) || timeline["rangeEndSecond"] != float64(1) { t.Fatalf("unexpected shared timeline: %#v", timeline) } payload := combinedAnnotationSubmissionInput{SliceSegments: []domain.SliceSegment{{ID: "slice-a", Name: "拿取前", Start: 0, End: 0.5}, {ID: "slice-b", Name: "拿取后", Start: 0.5, End: 1}}, Segments: []domain.AnnotationSegment{{ID: "description", LabelID: "dict-01", Description: "拿取商品", Start: 0, End: 0.5, Confidence: 1, Source: "human"}}} payload.Segments = append(payload.Segments, domain.AnnotationSegment{ID: "invalid", Description: "无效片段", Start: .5, End: 1}) materialization, err := server.materializeCombinedSliceSubmission(ctx, task, item, payload, 1) if err != nil { t.Fatal(err) } if materialization.Payload["status"] != "completed" || materialization.Payload["sliceCount"] != 2 { t.Fatalf("materialization=%#v", materialization.Payload) } for _, sliceID := range []string{"slice-000001", "slice-000002"} { sliceRoot := filepath.Join(materialization.Artifact.Path, "slices", sliceID) for _, name := range []string{"left.mp4", "right.mp4", "left_pts.csv", "right_pts.csv", "imu.csv", "annotation.json", "synchronized-slice.json"} { if info, statErr := os.Stat(filepath.Join(sliceRoot, name)); statErr != nil || info.Size() <= 0 { t.Fatalf("missing %s/%s: info=%#v err=%v", sliceID, name, info, statErr) } } } sliceRoot := filepath.Join(materialization.Artifact.Path, "slices", "slice-000001") var annotation map[string]any encoded, err := os.ReadFile(filepath.Join(sliceRoot, "annotation.json")) if err != nil || json.Unmarshal(encoded, &annotation) != nil { t.Fatalf("read annotation: %v", err) } window := annotation["window"].(map[string]any) if annotation["schemaVersion"] != "droboticflow.timestamped-description/v3" || annotation["sliceName"] != "拿取前" { t.Fatalf("description annotation=%#v", annotation) } descriptions := annotation["descriptions"].([]any) if len(descriptions) != 1 || descriptions[0].(map[string]any)["description"] != "拿取商品" { t.Fatalf("descriptions=%#v", descriptions) } if len(annotation["actions"].([]any)) != len(descriptions) { t.Fatalf("legacy package alias must mirror descriptions: %#v", annotation) } if window["startTimestampUs"].(float64) != 1_000_000 || window["endTimestampUs"].(float64) != 1_500_000 { t.Fatalf("timestamp window=%#v", window) } manifestBytes, err := os.ReadFile(filepath.Join(materialization.Artifact.Path, "revision-manifest.json")) if err != nil { t.Fatal(err) } var manifest map[string]any if err := json.Unmarshal(manifestBytes, &manifest); err != nil { t.Fatal(err) } coverage := manifest["coverage"].(map[string]any) if coverage["mode"] != "full_common_range" || coverage["contiguous"] != true || coverage["gapMicroseconds"].(float64) != 0 || coverage["sliceCount"].(float64) != 2 { t.Fatalf("coverage=%#v", coverage) } reconstruction := coverage["reconstruction"].(map[string]any) if reconstruction["leftFrameCount"].(float64) != 4 || reconstruction["rightFrameCount"].(float64) != 4 || reconstruction["imuRowCount"].(float64) != 8 { t.Fatalf("reconstruction=%#v", reconstruction) } if len(materialization.Slices) != 2 || materialization.CoverageStartSecond != 0 || materialization.CoverageEndSecond != 1 { t.Fatalf("normalized materialization=%#v", materialization) } stored, err := dataStore.GetRun(ctx, run.ID) if err != nil || stored == nil || len(stored.Artifacts) != 1 || stored.Artifacts[0].ID != materialization.Artifact.ID { t.Fatalf("stored run=%#v err=%v", stored, err) } retry, err := server.materializeCombinedSliceSubmission(ctx, task, item, payload, 1) if err != nil { t.Fatal(err) } if retry.Payload["sliceCount"] != materialization.Payload["sliceCount"] || len(retry.Slices) != len(materialization.Slices) || len(retry.Segments) != len(materialization.Segments) || retry.CoverageStartSecond != materialization.CoverageStartSecond || retry.CoverageEndSecond != materialization.CoverageEndSecond { t.Fatalf("idempotent retry must return the original normalized result: first=%#v retry=%#v", materialization, retry) } for index := range materialization.Slices { if retry.Slices[index].ID != materialization.Slices[index].ID || retry.Slices[index].Start != materialization.Slices[index].Start || retry.Slices[index].End != materialization.Slices[index].End || retry.Slices[index].AnnotationStatus != materialization.Slices[index].AnnotationStatus { t.Fatalf("retry slice %d differs: first=%#v retry=%#v", index, materialization.Slices[index], retry.Slices[index]) } } for index := range materialization.Segments { if retry.Segments[index].ID != materialization.Segments[index].ID || retry.Segments[index].Start != materialization.Segments[index].Start || retry.Segments[index].End != materialization.Segments[index].End { t.Fatalf("retry semantic segment %d differs: first=%#v retry=%#v", index, materialization.Segments[index], retry.Segments[index]) } } } func TestMaterializationDoesNotReuseAnotherCaptureRevision(t *testing.T) { dataStore := store.NewMemoryStore() task := domain.AnnotationTaskRecord{ID: "capture-b", RunID: "shared-run", NodeID: "human"} err := dataStore.UpsertRun(context.Background(), domain.RunRecord{ID: task.RunID, Artifacts: []domain.ExecutionArtifact{ {ID: "shared-run-human-materialized-revision-000001", Data: map[string]any{"coverage": map[string]any{"endSecond": 1.929}}}, {ID: "shared-run-human-capture-a-materialized-revision-000001", Data: map[string]any{"coverage": map[string]any{"endSecond": 1.929}}}, }}) if err != nil { t.Fatal(err) } server := &server{store: dataStore} result, err := server.materializeCombinedSliceSubmission(context.Background(), task, domain.HumanItemRecord{}, combinedAnnotationSubmissionInput{}, 1) if err == nil || result != nil { t.Fatalf("must validate capture-b sources rather than reuse capture-a or legacy cache: result=%#v err=%v", result, err) } } func TestSafeMaterializationSourcePathMapsBOSObjectToWorkspaceCSI(t *testing.T) { workspace := t.TempDir() key := "projects/project/workflows/workflow/runs/run/node/artifact/left.mp4" local := filepath.Join(workspace, filepath.FromSlash(key)) if err := os.MkdirAll(filepath.Dir(local), 0o755); err != nil { t.Fatal(err) } if err := os.WriteFile(local, []byte("video"), 0o644); err != nil { t.Fatal(err) } server := &server{workspaceMountPath: workspace} artifact := domain.ExecutionArtifact{Name: "left.mp4", Path: "bos://drobodata-fanyu/" + key} resolved, err := server.safeMaterializationSourcePath(&artifact) if err != nil || resolved != local { t.Fatalf("resolved=%q err=%v", resolved, err) } } func TestAnnotationFrameTimelinePayloadKeepsExactPTSBoundaries(t *testing.T) { payload, err := annotationFrameTimelinePayload("left", []hardwarePTSRow{ {TimestampUS: 1_000_000}, {TimestampUS: 1_033_333}, {TimestampUS: 1_066_667}, }) if err != nil { t.Fatal(err) } if payload["frameCount"] != 3 || payload["originTimestampUs"] != int64(1_000_000) { t.Fatalf("unexpected timeline metadata: %#v", payload) } boundaries, ok := payload["boundariesSeconds"].([]float64) if !ok || len(boundaries) != 4 { t.Fatalf("unexpected timeline boundaries: %#v", payload["boundariesSeconds"]) } if boundaries[0] != 0 || math.Abs(boundaries[1]-0.033333) > 0.000001 || math.Abs(boundaries[3]-0.100001) > 0.000001 { t.Fatalf("PTS boundaries were not preserved: %#v", boundaries) } }