droboticflow/internal/api/slice_phase_browser_test.go
Codex 8d4b672649
Some checks are pending
web-ci / checks (push) Waiting to run
web-ci / pool-search-mongo (push) Waiting to run
🚑 Restore annotation workflows with advisory source audits
2026-11-11 19:58:23 -08:00

285 lines
14 KiB
Go

package api
import (
"context"
"droboticflow/internal/config"
"fmt"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
"droboticflow/internal/domain"
"droboticflow/internal/store"
)
// Actual page -> actual HTTP handler -> isolated memory store. Neither a
// production endpoint nor the local snapshot database is reachable here.
func TestSlicePhaseBrowserReplica(t *testing.T) {
if os.Getenv("REWORK_BOUNDARY_BROWSER_TEST") != "1" {
t.Skip("local browser opt-in")
}
f := continuousFixture(t)
initial := os.Getenv("INITIAL_SLICE_CONFIRM_BROWSER_TEST") == "1"
if initial {
labels, err := f.store.GetProjectAnnotationLabels(f.ctx, f.task.ProjectID)
if err != nil || labels == nil {
t.Fatal("fixture labels unavailable", err)
}
extra := domain.NewID("test-slice-label")
if err := f.store.UpsertAnnotationLabel(f.ctx, domain.AnnotationLabelRecord{ID: extra, OrganizationID: f.task.OrganizationID, Kind: "slice", Code: extra, Name: "重新选择切片", Status: domain.AnnotationLabelActive}); err != nil {
t.Fatal(err)
}
labels.SliceLabelIDs = append(labels.SliceLabelIDs, extra)
if err := f.store.UpsertProjectSliceLabels(f.ctx, *labels); err != nil {
t.Fatal(err)
}
}
reason := dispositionFixturePayload(t, f)
if err := f.store.UpsertOrganizationPlugin(f.ctx, domain.OrganizationPluginRecord{OrganizationID: domain.DefaultOrganizationID, PluginID: "annotation-qa", Enabled: true, Config: defaultAnnotationPluginConfig()}); err != nil {
t.Fatal(err)
}
reset := func(status, shape string) error {
before := []domain.SliceSegment{{ID: "first", Start: 0, End: 10}}
if initial {
before[0].Name = "测试切片"
}
item := f.item
item.Subject.ArtifactID = "left-video"
item.ReviewRound = 0
actions := []domain.AnnotationSegment{{ID: "pending-first", Start: 0, End: 10, Status: "pending"}}
if status == "empty" {
actions = []domain.AnnotationSegment{}
}
item.Subject.Payload = map[string]any{"rightArtifactId": "right-video", "sliceWorkflow": map[string]any{"status": "editing", "phase": "slice"}, "annotationWorkspace": map[string]any{"userId": f.annotator.ID, "savedAt": nowISO(), "sliceSegments": before, "segments": actions, "statuses": map[string]string{"first": "pending"}}}
if status == "malformed" {
item.Subject.Payload["annotationWorkspace"].(map[string]any)["segments"] = map[string]any{"id": "retained-invalid-shape", "description": "保留异常旧内容"}
}
if status == "legacy" {
delete(item.Subject.Payload, "sliceWorkflow")
}
if status == "failed" {
item.Subject.Payload["sliceWorkflow"] = map[string]any{"status": "failed", "phase": "materializing", "revision": 1, "error": "isolated synthetic interrupted generation"}
}
if status == "draft" {
item.Subject.Payload["annotationDraft"] = map[string]any{"userId": f.annotator.ID, "savedAt": time.Now().Add(time.Second).UTC().Format(time.RFC3339Nano), "savedVersion": item.Version, "sliceSegments": before, "segments": actions, "statuses": map[string]string{"first": "pending"}}
item.Subject.Payload["annotationWorkspace"].(map[string]any)["segments"] = []domain.AnnotationSegment{}
}
if shape == "two" {
before = []domain.SliceSegment{{ID: "first", Name: "测试切片", Start: 0, End: 0.2}, {ID: "second", Start: 0.2, End: 10}}
actions = []domain.AnnotationSegment{{ID: "a", Start: 0, End: 0.2, Status: "pending"}, {ID: "b", Start: 0.2, End: 10, Status: "pending"}}
item.Subject.Payload["annotationWorkspace"].(map[string]any)["sliceSegments"] = before
item.Subject.Payload["annotationWorkspace"].(map[string]any)["segments"] = actions
}
if shape == "rework" {
before = []domain.SliceSegment{{ID: "first", Name: "测试切片", Start: 0, End: 5, AnnotationStatus: "pending"}, {ID: "discard", Start: 5, End: 10, DeliveryDisposition: "discard", DiscardReason: "相机被遮挡", DiscardReasonLabelID: reason.ReasonLabelID, DiscardReasonVersion: reason.ReasonVersion}}
actions = []domain.AnnotationSegment{{ID: "a", Start: 0, End: 5, Status: "described", Description: "原描述"}}
item.ReviewRound = 1
item.Subject.Payload["sliceWorkflow"] = map[string]any{"status": "completed", "phase": "annotate"}
item.Subject.Payload["annotationWorkspace"].(map[string]any)["sliceSegments"] = before
item.Subject.Payload["annotationWorkspace"].(map[string]any)["segments"] = actions
frozen := append([]domain.SliceSegment(nil), before...)
frozen[0].AnnotationStatus = "labeled"
if err := f.store.UpsertReworkBaseline(f.ctx, domain.ReworkBaselineRecord{ID: store.ReworkBaselineID(item.ID, 1), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, ItemID: item.ID, Round: 1, StageID: domain.FanyuV58StageAnnotationCombined, Slices: frozen, Actions: actions, Problems: []domain.ReviewProblem{{ID: "p-slice", Scope: "slice", SliceID: "first", Text: "核对切片"}, {ID: "p-action", Scope: "action", SliceID: "first", ActionID: "a", Text: "核对描述"}}}); err != nil {
return err
}
}
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
return err
}
if status == "deleted-reset" {
// An actual deletion/reset followed by a different account opening
// the same source. Never synthesize the resulting editor response.
if err := f.store.UpsertSliceRevision(f.ctx, domain.SliceRevisionRecord{ID: "old-user-cut", OrganizationID: item.OrganizationID, TaskID: f.task.ID, Revision: 1, AuthorUserID: f.annotator.ID, Segments: before}); err != nil {
return err
}
deleted := f.annotator
deleted.Status = domain.UserStatusDisabled
deleted.DeletionRequestedAt = nowISO()
deleted.DeletionActorID = f.admin.ID
if err := f.store.UpsertUser(f.ctx, deleted); err != nil {
return err
}
deletion := &server{store: f.store}
if err := deletion.finishAccountDeletion(f.ctx, deleted); err != nil {
return err
}
recipient := f.annotator
recipient.ID = "replacement-annotator"
if err := f.store.UpsertUser(f.ctx, recipient); err != nil {
return err
}
if err := f.store.UpsertProjectMember(f.ctx, domain.ProjectMemberRecord{ID: "replacement-member", OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: recipient.ID, SupplierID: recipient.SupplierID, Roles: []domain.AnnotationAssignmentRole{domain.AnnotationRoleAnnotator}}); err != nil {
return err
}
fresh, err := f.store.GetHumanItem(f.ctx, item.ID)
if err != nil {
return err
}
version := fresh.Version
fresh.AssignedUserID = recipient.ID
fresh.Status = domain.HumanItemClaimed
fresh.Version++
if ok, err := f.store.UpdateHumanItemVersioned(f.ctx, *fresh, version); err != nil || !ok {
return fmt.Errorf("synthetic replacement claim: %v", err)
}
f.annotator = recipient
}
return nil
}
root := t.TempDir()
f.task.SourceVideo = "/api/runs/" + f.task.RunID + "/artifacts/left-video/content"
f.task.RightSourceVideo = "/api/runs/" + f.task.RunID + "/artifacts/right-video/content"
f.task.NodeID = "human"
f.task.SourceVideo = "/api/runs/" + f.task.RunID + "/artifacts/left-video/content"
f.task.RightSourceVideo = "/api/runs/" + f.task.RunID + "/artifacts/right-video/content"
f.task.NodeID = "human"
f.task.ArtifactID = "left-video"
f.task.RightArtifactID = "right-video"
f.task.SourceIsFullVideo = true
f.task.SourceDurationSeconds = 10
f.task.CoverageEndSecond = 10
pts := "timestamp_us\n"
for i := 0; i < 100; i++ {
pts += fmt.Sprintf("%d\n", 1000000+i*100000)
}
bindings := []domain.NodeInputBinding{}
mediaArtifacts := []domain.ExecutionArtifact{}
for _, side := range []string{"left", "right"} {
video := filepath.Join(root, side+".mp4")
if out, err := exec.Command("ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "color=c=navy:s=160x90:r=10:d=10", "-c:v", "libx264", "-pix_fmt", "yuv420p", video).CombinedOutput(); err != nil {
t.Fatalf("video: %v: %s", err, out)
}
timestamps := filepath.Join(root, side+"_pts.csv")
if err := os.WriteFile(timestamps, []byte(pts), 0600); err != nil {
t.Fatal(err)
}
mediaArtifacts = append(mediaArtifacts, domain.ExecutionArtifact{ID: side + "-video", Name: side + ".mp4", Path: video, Type: domain.PortTypeVideo})
port := "fullLeftVideos"
if side == "right" {
port = "fullRightVideos"
}
bindings = append(bindings, domain.NodeInputBinding{TargetPortID: port, Artifacts: []domain.ExecutionArtifact{{ID: side + "-video", Name: side + ".mp4", Path: video, Data: map[string]any{"collectionId": "capture"}}}}, domain.NodeInputBinding{TargetPortID: side + "Timestamps", Artifacts: []domain.ExecutionArtifact{{ID: side + "-pts", Name: side + "_pts.csv", Path: timestamps, Data: map[string]any{"collectionId": "capture"}}}})
}
imu := "timestamp_us,x,y,z,type\n"
for i := 0; i < 100; i++ {
stamp := 1000000 + i*100000
imu += fmt.Sprintf("%d,1,2,3,accel\n%d,4,5,6,gyro\n", stamp, stamp)
}
imuPath := filepath.Join(root, "imu.csv")
if err := os.WriteFile(imuPath, []byte(imu), 0600); err != nil {
t.Fatal(err)
}
bindings = append(bindings, domain.NodeInputBinding{TargetPortID: "imu", Artifacts: []domain.ExecutionArtifact{{ID: "imu", Name: "imu.csv", Path: imuPath, Data: map[string]any{"collectionId": "capture"}}}})
if err := f.store.UpsertRun(f.ctx, domain.RunRecord{ID: f.task.RunID, OrganizationID: f.task.OrganizationID, ProjectID: f.task.ProjectID, WorkflowID: f.task.WorkflowID, Artifacts: mediaArtifacts, NodeExecutions: []domain.NodeExecutionRecord{{NodeID: f.task.NodeID, InputBindings: bindings}}}); err != nil {
t.Fatal(err)
}
if err := f.store.UpsertAnnotationTask(f.ctx, f.task); err != nil {
t.Fatal(err)
}
if err := reset("pending", ""); err != nil {
t.Fatal(err)
}
if !store.AnnotationSourceAuditAdvisory() {
// The slice phase requires the real validator's admission evidence, unlike
// an already materialized rework fixture. Process only isolated synthetic media.
t.Setenv("ANNOTATION_PROCESSOR_ROLE", "validation")
validationCtx, stopValidation := context.WithTimeout(t.Context(), 30*time.Second)
validationDone := make(chan error, 1)
go func() {
validationDone <- RunAnnotationProcessor(validationCtx, f.store, config.AppConfig{WorkspaceMountPath: root}, 1, false)
}()
var validationStatus string
for validationCtx.Err() == nil {
job, e := f.store.GetAnnotationIndexJob(validationCtx, f.task.ID)
if e != nil {
stopValidation()
<-validationDone
t.Fatal(e)
}
if job != nil {
validationStatus = job.Status
if job.Status == "completed" || job.Status == "failed" {
break
}
}
time.Sleep(20 * time.Millisecond)
}
stopValidation()
<-validationDone
if validationStatus != "completed" {
t.Fatalf("synthetic source validation did not complete: %s", validationStatus)
}
}
handler := NewHandlerWithConfig(f.store, nil, config.AppConfig{WorkspaceMountPath: root})
unavailableDictionaryHandler := NewHandler(annotationDictionaryReadFailure{f.store, context.DeadlineExceeded}, nil)
var failDictionarySave atomic.Bool
failDictionarySave.Store(os.Getenv("INITIAL_SLICE_CONFIRM_SCENARIO") == "save-dictionary")
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/api/auth/me" {
renderJSON(w, 200, map[string]any{"user": sanitizeUser(&f.annotator), "organization": domain.OrganizationRecord{ID: domain.DefaultOrganizationID, Status: domain.OrganizationStatusActive}})
return
}
if r.URL.Path == "/__boundary/reset" {
if err := reset(r.URL.Query().Get("status"), r.URL.Query().Get("shape")); err != nil {
renderError(w, 500, err)
return
}
renderJSON(w, 200, map[string]any{"ok": true})
return
}
if r.URL.Path == "/__boundary/state" {
item, _ := f.store.GetHumanItem(r.Context(), f.item.ID)
renderJSON(w, 200, item)
return
}
if r.Method != "GET" && r.Method != "HEAD" && !strings.HasSuffix(r.URL.Path, "/slice-edit-applications") && !strings.HasSuffix(r.URL.Path, "/slice-edit-restorations") && !strings.HasSuffix(r.URL.Path, "/drafts") && !(initial && strings.HasSuffix(r.URL.Path, "/slice-confirmations")) {
renderJSON(w, 403, map[string]string{"error": "fixture write not permitted"})
return
}
r.AddCookie(&http.Cookie{Name: csrfCookieName, Value: "boundary-local-csrf"})
r.Header.Set(csrfHeaderName, "boundary-local-csrf")
r = r.WithContext(context.WithValue(r.Context(), authContextKey{}, &authenticatedPrincipal{User: f.annotator, Organization: domain.OrganizationRecord{ID: domain.DefaultOrganizationID, Status: domain.OrganizationStatusActive}}))
if r.Method == http.MethodPut && strings.HasSuffix(r.URL.Path, "/drafts") && failDictionarySave.Swap(false) {
unavailableDictionaryHandler.ServeHTTP(w, r)
return
}
handler.ServeHTTP(w, r)
}))
defer server.Close()
ctx, cancel := context.WithTimeout(t.Context(), 3*time.Minute)
defer cancel()
script := "tests/browser/slice-phase-replica.mjs"
if initial {
script = "tests/browser/initial-slice-confirmation.mjs"
}
cmd := exec.CommandContext(ctx, "node", script)
cmd.Dir = "../.."
cmd.Env = append(os.Environ(), "REWORK_BOUNDARY_API="+server.URL)
out, err := cmd.CombinedOutput()
t.Log(string(out))
if err != nil {
t.Fatal(fmt.Errorf("browser: %w", err))
}
}
func TestInitialSliceConfirmationBrowserReplica(t *testing.T) {
if os.Getenv("INITIAL_SLICE_CONFIRM_BROWSER_TEST") != "1" {
t.Skip("local browser opt-in")
}
t.Setenv("REWORK_BOUNDARY_BROWSER_TEST", "1")
for _, scenario := range []string{"pending", "edited", "legacy", "failed", "save-retry", "save-throttle", "save-timeout", "save-dictionary", "deleted-reset", "malformed"} {
t.Run(scenario, func(t *testing.T) {
t.Setenv("INITIAL_SLICE_CONFIRM_SCENARIO", scenario)
TestSlicePhaseBrowserReplica(t)
})
}
}