package api import ( "encoding/json" "net/http" "os" "os/exec" "path/filepath" "reflect" "strings" "testing" "time" "droboticflow/internal/config" "droboticflow/internal/domain" ) func TestSourceAdvisoryPublishedReviewDoesNotRequireFullAudit(t *testing.T) { t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory") t.Setenv("ANNOTATION_PROCESSOR_MODE", "external") f, root := annotationProcessorFixture(t) f.item.CurrentStageID = "quality_review" f.item.Subject.Payload["annotationWorkspace"] = map[string]any{"description": "保留已有标注"} if e := f.store.UpsertHumanItem(f.ctx, f.item); e != nil { t.Fatal(e) } before, _ := f.store.GetHumanItem(f.ctx, f.item.ID) j := &domain.AnnotationIndexJob{ID: f.task.ID, OrganizationID: f.task.OrganizationID, ProjectID: f.task.ProjectID, RunID: f.task.RunID, Status: "failed", Error: "source video duration does not match its fixed frame cadence"} probe := &sourceProofReadStore{MemoryStore: f.store, timeline: j} f.handler = NewHandlerWithConfig(probe, nil, config.AppConfig{WorkspaceMountPath: root}) r := f.request(http.MethodGet, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"?view=status", f.admin, nil) var response struct { SourceValidation annotationSourceValidation `json:"sourceValidation"` } if r.Code != 200 || json.Unmarshal(r.Body.Bytes(), &response) != nil || response.SourceValidation.blocked() || response.SourceValidation.Required { t.Fatalf("review remains blocked: %d %s", r.Code, r.Body.String()) } r = f.request(http.MethodGet, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/frame-timeline", f.admin, nil) if r.Code != 200 { t.Fatalf("review timeline: %d %s", r.Code, r.Body.String()) } after, _ := f.store.GetHumanItem(f.ctx, f.item.ID) if probe.taskWrites != 0 || !reflect.DeepEqual(before, after) { t.Fatal("review read rewrote saved work") } } func TestSourceAdvisoryPreparesIndexDespiteCadenceAuditFailure(t *testing.T) { t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory") f, root := annotationProcessorFixture(t) makeCadenceAuditFailure(t, root) s := &server{store: f.store, workspaceMountPath: root} run, _ := f.store.GetRun(f.ctx, f.task.RunID) fp, e := s.annotationSourceFingerprint(f.ctx, f.task, *run) if e != nil { t.Fatal(e) } if e = s.requirePreparedAnnotationSource(f.ctx, f.task, fp, false); e != nil { t.Fatalf("operational source blocked by audit: %v", e) } full, _ := f.store.GetAnnotationTimelineIndex(f.ctx, sourceCertificateID(f.task.OrganizationID, fp)) if full != nil { t.Fatal("basic index masquerades as full source certificate") } index, _ := f.store.GetAnnotationTimelineIndex(f.ctx, "annotation-processing-v1:"+f.task.OrganizationID+":"+fp) if index == nil { t.Fatal("missing durable processing index") } if _, e = decodeSourceCertificate(index, fp); e == nil { t.Fatal("strict decoder accepted an operational index") } duration, e := ffprobeDurationSeconds(f.ctx, filepath.Join(root, "left.mp4")) if e != nil { t.Fatal(e) } if e = validateSourceMediaClock(f.ctx, filepath.Join(root, "left.mp4"), 31, duration); e == nil { t.Fatal("strict audit regression was not exercised") } if _, e = s.annotationSourceIndexForMode(f.ctx, f.task, *run, fp, false); e == nil { t.Fatal("explicit full audit reused an operational index") } t.Setenv("PATH", t.TempDir()) restarted := &server{store: f.store, workspaceMountPath: root} if e = restarted.requirePreparedAnnotationSource(f.ctx, f.task, fp, false); e != nil { t.Fatalf("restart failed to reuse operational index without media tools: %v", e) } } func makeCadenceAuditFailure(t *testing.T, root string) { t.Helper() for _, side := range []string{"left", "right"} { video := filepath.Join(root, side+".mp4") if out, e := exec.Command("ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "testsrc2=s=64x48:r=8:d=4", "-vf", "select=not(eq(n\\,16))", "-fps_mode", "vfr", "-c:v", "libx264", "-pix_fmt", "yuv420p", video).CombinedOutput(); e != nil { t.Fatalf("fixture: %v %s", e, out) } pts := filepath.Join(root, side+"_pts.csv") body, e := os.ReadFile(pts) if e != nil { t.Fatal(e) } if e = os.WriteFile(pts, []byte(strings.Replace(string(body), "3000000\n", "", 1)), 0600); e != nil { t.Fatal(e) } } } func TestSourceAdvisoryCompleteWorkAndReviewFlow(t *testing.T) { t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory") t.Setenv("ANNOTATION_SOURCE_INDEX", "true") t.Setenv("ANNOTATION_PROCESSOR_MODE", "external") f, root := annotationProcessorFixture(t) makeCadenceAuditFailure(t, root) one, zero := 1.0, 0.0 f.item.AcceptanceSampleProbability = &one f.item.AcceptanceSampleValue = &zero if e := f.store.UpsertHumanItem(f.ctx, f.item); e != nil { t.Fatal(e) } batch, _ := f.store.GetHumanBatch(f.ctx, f.item.BatchID) batch.RequirePrePackageAcceptance = true if e := f.store.UpsertHumanBatch(f.ctx, *batch); e != nil { t.Fatal(e) } engine := &server{store: f.store, workspaceMountPath: root} timeline, e := engine.annotationFrameTimelineForTask(f.ctx, f.task, "left") if e != nil { t.Fatal(e) } points := timeline["boundariesSeconds"].([]float64) selected := []domain.SliceSegment{{ID: "a", Name: "测试切片", Start: points[0], End: points[len(points)/2]}, {ID: "b", Name: "测试切片", Start: points[len(points)/2], End: points[len(points)-1]}} testDurableAnnotationOutbox(t, f, root, selected) h, _ := f.store.GetHumanItem(f.ctx, f.item.ID) r := f.request(http.MethodPost, "/api/human-items/"+h.ID+"/claim", f.annotator, map[string]any{"version": h.Version}) if r.Code != 403 { t.Fatalf("annotator can self-review: %d %s", r.Code, r.Body.String()) } promoted := f.annotator promoted.Role = domain.UserRoleQualityReviewer if e := f.store.UpsertUser(f.ctx, promoted); e != nil { t.Fatal(e) } r = f.request(http.MethodPost, "/api/human-items/"+h.ID+"/claim", promoted, map[string]any{"version": h.Version}) if r.Code != 403 { t.Fatalf("promoted author can self-review: %d %s", r.Code, r.Body.String()) } if e := f.store.UpsertUser(f.ctx, f.annotator); e != nil { t.Fatal(e) } r = f.request(http.MethodPost, "/api/human-items/"+h.ID+"/claim", f.reviewer, map[string]any{"version": h.Version - 1}) if r.Code != 409 { t.Fatalf("stale version admitted: %d %s", r.Code, r.Body.String()) } r = f.request(http.MethodPost, "/api/human-items/"+h.ID+"/claim", f.reviewer, map[string]any{"version": h.Version}) if r.Code != 200 { t.Fatalf("quality claim: %d %s", r.Code, r.Body.String()) } for _, side := range []string{"left", "right"} { if e := os.Remove(filepath.Join(root, side+".mp4")); e != nil { t.Fatal(e) } } f.handler = NewHandlerWithConfig(f.store, nil, config.AppConfig{WorkspaceMountPath: root}) r = f.request(http.MethodGet, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/frame-timeline", f.reviewer, nil) if r.Code != 200 { t.Fatalf("published review depends on removed originals: %d %s", r.Code, r.Body.String()) } r = f.request(http.MethodPost, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/reviews", f.reviewer, map[string]any{"stage": "quality", "decision": "approved"}) if r.Code != 201 { t.Fatalf("quality review: %d %s", r.Code, r.Body.String()) } var aggregate *domain.HumanItemRecord deadline := time.Now().Add(3 * time.Second) for time.Now().Before(deadline) { aggregate, e = f.store.GetHumanItem(f.ctx, fanyuV5PrePackageAcceptanceItemID(f.item.BatchID)) if e != nil || aggregate != nil { break } time.Sleep(10 * time.Millisecond) } if e != nil || aggregate == nil { recovery := &server{store: f.store, workspaceMountPath: root, annotationSourceIndex: true} _, e = recovery.ensureFanyuV5PrePackageAcceptance(f.ctx, batch) aggregate, _ = f.store.GetHumanItem(f.ctx, fanyuV5PrePackageAcceptanceItemID(f.item.BatchID)) if e != nil || aggregate == nil { t.Fatalf("missing final acceptance: %v", e) } } acceptance := domain.UserRecord{ID: "availability-acceptance", OrganizationID: f.task.OrganizationID, Role: domain.UserRoleAcceptanceReviewer, Status: domain.UserStatusActive, SupplierID: f.annotator.SupplierID, AcceptanceAccessMode: "managed"} if e = f.store.UpsertUser(f.ctx, acceptance); e != nil { t.Fatal(e) } if _, e = f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.task.OrganizationID, f.annotator.SupplierID, true, 0, f.admin.ID); e != nil { t.Fatal(e) } if e = f.store.UpsertProjectAnnotationMembership(f.ctx, domain.ProjectAnnotationMembershipRecord{ID: "availability-acceptance-membership", OrganizationID: f.task.OrganizationID, ProjectID: f.task.ProjectID, UserID: acceptance.ID, AssignmentRole: domain.AnnotationRoleAcceptanceReviewer}); e != nil { t.Fatal(e) } r = f.request(http.MethodPost, "/api/human-items/"+aggregate.ID+"/claim", f.reviewer, map[string]any{"version": aggregate.Version}) if r.Code != 403 { t.Fatalf("quality role reached acceptance: %d %s", r.Code, r.Body.String()) } r = f.request(http.MethodPost, "/api/human-items/"+aggregate.ID+"/claim", acceptance, map[string]any{"version": aggregate.Version}) if r.Code != 200 { t.Fatalf("acceptance claim: %d %s", r.Code, r.Body.String()) } aggregate, _ = f.store.GetHumanItem(f.ctx, aggregate.ID) r = f.request(http.MethodPost, "/api/human-items/"+aggregate.ID+"/decisions", acceptance, map[string]any{"version": aggregate.Version, "decision": "approved", "poseDelivery": map[string]any{"headpose": "exclude", "handpose": "exclude", "reasonCodes": []string{"not_required"}}}) if r.Code != 200 { t.Fatalf("final acceptance: %d %s", r.Code, r.Body.String()) } aggregate, _ = f.store.GetHumanItem(f.ctx, aggregate.ID) if aggregate.Status != domain.HumanItemAccepted { t.Fatalf("acceptance not published: %s", aggregate.Status) } } func TestSourceAdvisoryIsolatedReworkDoesNotTrapRandomClaim(t *testing.T) { t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory") f := randomClaimFixture(t, 1, false) f.item.ReviewRound = 1 f.item.Status = domain.HumanItemRework f.item.ProcessingJob = &domain.AnnotationProcessingJob{Status: "failed", Error: "基础帧映射不可用:video frame count mismatch"} f.item.Subject.Payload["annotationDraft"] = map[string]any{"description": "保留隔离任务"} if e := f.store.UpsertHumanItem(f.ctx, f.item); e != nil { t.Fatal(e) } before, _ := f.store.GetHumanItem(f.ctx, f.item.ID) claimed := claimRandom(t, f, "advisory-isolated-rework-claim-01") if claimed.ID != "random-item-0" { t.Fatalf("isolated rework trapped claim: %s", claimed.ID) } after, _ := f.store.GetHumanItem(f.ctx, f.item.ID) if !reflect.DeepEqual(before, after) { t.Fatal("isolated task annotations/ownership changed") } } func TestSourceAdvisoryOwnedFailureCanRetryTimeline(t *testing.T) { t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory") f, root := annotationProcessorFixture(t) f.item.ProcessingJob = &domain.AnnotationProcessingJob{Status: "failed", Error: "基础帧映射不可用:previous media unavailable"} f.item.Subject.Payload["annotationDraft"] = map[string]any{"description": "保留失败标注"} if e := f.store.UpsertHumanItem(f.ctx, f.item); e != nil { t.Fatal(e) } before, _ := f.store.GetHumanItem(f.ctx, f.item.ID) f.handler = NewHandlerWithConfig(f.store, nil, config.AppConfig{WorkspaceMountPath: root}) r := f.request(http.MethodGet, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/frame-timeline", f.annotator, nil) if r.Code != 200 { t.Fatalf("repaired mapping permanently blocked by prior job: %d %s", r.Code, r.Body.String()) } after, _ := f.store.GetHumanItem(f.ctx, f.item.ID) if !reflect.DeepEqual(before, after) { t.Fatal("re-read rewrote annotations/ownership") } }