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