droboticflow/internal/api/human_slice_materialization_test.go
2026-09-02 03:12:00 +08:00

200 lines
10 KiB
Go

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{}}}
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"}}}
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 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)
}
}