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