forked from longtao.wu/droboticflow
226 lines
13 KiB
Go
226 lines
13 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
)
|
|
|
|
type combinedDraftFixture struct {
|
|
ctx context.Context
|
|
store *store.MemoryStore
|
|
handler http.Handler
|
|
annotator domain.UserRecord
|
|
reviewer domain.UserRecord
|
|
task domain.AnnotationTaskRecord
|
|
item domain.HumanItemRecord
|
|
}
|
|
|
|
func newCombinedDraftFixture(t *testing.T) combinedDraftFixture {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
dataStore := store.NewMemoryStore()
|
|
annotator := domain.UserRecord{ID: "draft-annotator", OrganizationID: domain.DefaultOrganizationID, Role: domain.UserRoleAnnotator, Status: domain.UserStatusActive}
|
|
reviewer := domain.UserRecord{ID: "draft-reviewer", OrganizationID: domain.DefaultOrganizationID, Role: domain.UserRoleQualityReviewer, Status: domain.UserStatusActive}
|
|
for _, user := range []domain.UserRecord{annotator, reviewer} {
|
|
if err := dataStore.UpsertUser(ctx, user); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
projectID, workflowID := "draft-project", "draft-workflow"
|
|
if err := dataStore.UpsertProject(ctx, domain.ProjectRecord{ID: projectID, OrganizationID: domain.DefaultOrganizationID, Name: "泛宇草稿项目"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := dataStore.UpsertWorkflow(ctx, domain.WorkflowRecord{ID: workflowID, OrganizationID: domain.DefaultOrganizationID, ProjectID: projectID, Name: "持续标注工作流"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := dataStore.UpsertAnnotationTemplate(ctx, domain.AnnotationTemplateRecord{ID: "draft-template", OrganizationID: domain.DefaultOrganizationID, ProjectID: projectID, Name: "22 类语义", Version: 6, Status: domain.AnnotationTemplatePublished, Labels: domain.ConvenienceStore22SemanticLabels()}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, membership := range []domain.ProjectAnnotationMembershipRecord{
|
|
{ID: "draft-annotator-membership", OrganizationID: domain.DefaultOrganizationID, ProjectID: projectID, UserID: annotator.ID, AssignmentRole: domain.AnnotationRoleAnnotator},
|
|
{ID: "draft-reviewer-membership", OrganizationID: domain.DefaultOrganizationID, ProjectID: projectID, UserID: reviewer.ID, AssignmentRole: domain.AnnotationRoleQualityReviewer},
|
|
} {
|
|
if err := dataStore.UpsertProjectAnnotationMembership(ctx, membership); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
batch := domain.HumanBatchRecord{ID: "draft-batch", OrganizationID: domain.DefaultOrganizationID, PluginID: "annotation-qa", ProjectID: projectID, WorkflowID: workflowID, RunID: "draft-run", Stages: domain.DefaultFanyuV58HumanStages(), Status: domain.HumanBatchActive}
|
|
if err := dataStore.UpsertHumanBatch(ctx, batch); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task := domain.AnnotationTaskRecord{ID: "draft-task", OrganizationID: domain.DefaultOrganizationID, ProjectID: projectID, WorkflowID: workflowID, RunID: batch.RunID, SourceVideo: "capture-custom/camera_left.mp4", ClipStart: 0, ClipEnd: 10, TemplateID: "draft-template", TemplateVersion: 6, Status: domain.AnnotationTaskStatusPendingAnnotation}
|
|
if err := dataStore.UpsertAnnotationTask(ctx, task); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
item := domain.HumanItemRecord{ID: "draft-item", OrganizationID: domain.DefaultOrganizationID, PluginID: "annotation-qa", BatchID: batch.ID, ProjectID: projectID, WorkflowID: workflowID, RunID: batch.RunID, LegacyTaskID: task.ID, CurrentStageID: domain.FanyuV58StageAnnotationCombined, Status: domain.HumanItemClaimed, AssignedUserID: annotator.ID, Version: 4, Subject: domain.HumanSubjectRef{ItemKey: "capture-custom/camera_left.mp4", Payload: map[string]any{"preserved": true, "captureDirectory": "capture-custom"}}}
|
|
if err := dataStore.UpsertHumanItem(ctx, item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return combinedDraftFixture{ctx: ctx, store: dataStore, handler: NewHandler(dataStore, nil), annotator: annotator, reviewer: reviewer, task: task, item: item}
|
|
}
|
|
|
|
func (fixture combinedDraftFixture) request(method string, target string, user domain.UserRecord, body any) *httptest.ResponseRecorder {
|
|
encoded, _ := json.Marshal(body)
|
|
request := httptest.NewRequest(method, target, bytes.NewReader(encoded))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
csrf := "combined-draft-csrf"
|
|
request.AddCookie(&http.Cookie{Name: csrfCookieName, Value: csrf})
|
|
request.Header.Set(csrfHeaderName, csrf)
|
|
request = request.WithContext(context.WithValue(request.Context(), authContextKey{}, &authenticatedPrincipal{User: user, Organization: domain.OrganizationRecord{ID: domain.DefaultOrganizationID, Status: domain.OrganizationStatusActive}}))
|
|
recorder := httptest.NewRecorder()
|
|
fixture.handler.ServeHTTP(recorder, request)
|
|
return recorder
|
|
}
|
|
|
|
func TestCombinedAnnotationDraftUsesHumanItemCASWithoutAdvancingStage(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
payload := map[string]any{
|
|
"version": fixture.item.Version,
|
|
"sliceSegments": []map[string]any{
|
|
{"id": "slice-001", "start": 0.0, "end": 5.0, "annotationStatus": "labeled"},
|
|
{"id": "slice-002", "start": 5.0, "end": 10.0, "annotationStatus": "empty_confirmed"},
|
|
},
|
|
"operations": []map[string]any{{"type": "resize", "segmentIds": []string{"slice-001"}}},
|
|
"segments": []map[string]any{{"id": "event-001", "labelId": "01", "label": "鲜食处理", "start": 1.0, "end": 2.0, "confidence": 1.0}},
|
|
"statuses": map[string]string{"slice-001": "labeled", "slice-002": "empty_confirmed"},
|
|
}
|
|
recorder := fixture.request(http.MethodPut, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/drafts", fixture.annotator, payload)
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("save draft status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
stored, err := fixture.store.GetHumanItem(fixture.ctx, fixture.item.ID)
|
|
if err != nil || stored == nil {
|
|
t.Fatalf("stored item=%#v err=%v", stored, err)
|
|
}
|
|
if stored.Version != fixture.item.Version+1 || stored.CurrentStageID != domain.FanyuV58StageAnnotationCombined || stored.Status != domain.HumanItemClaimed || stored.AssignedUserID != fixture.annotator.ID {
|
|
t.Fatalf("draft must only advance CAS version: %#v", stored)
|
|
}
|
|
draft := mapValue(stored.Subject.Payload["annotationDraft"])
|
|
if draft["userId"] != fixture.annotator.ID || stringValue(draft["savedAt"]) == "" || mapValue(stored.Subject.Payload)["preserved"] != true {
|
|
t.Fatalf("draft metadata or existing payload missing: %#v", stored.Subject.Payload)
|
|
}
|
|
if len(normalizeStructuredValue(draft["sliceSegments"]).([]any)) != 2 || len(normalizeStructuredValue(draft["operations"]).([]any)) != 1 {
|
|
t.Fatalf("draft content=%#v", draft)
|
|
}
|
|
statuses := mapValue(draft["statuses"])
|
|
if stringValue(statuses["slice-001"]) != "labeled" || stringValue(statuses["slice-002"]) != "empty_confirmed" {
|
|
t.Fatalf("draft statuses=%#v", statuses)
|
|
}
|
|
|
|
stale := fixture.request(http.MethodPut, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/drafts", fixture.annotator, payload)
|
|
if stale.Code != http.StatusConflict {
|
|
t.Fatalf("stale draft status=%d body=%s", stale.Code, stale.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestCombinedAnnotationDraftRejectsNonAnnotatorEvenWhenTaskIsVisible(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
recorder := fixture.request(http.MethodPut, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/drafts", fixture.reviewer, map[string]any{
|
|
"version": fixture.item.Version, "sliceSegments": []map[string]any{{"id": "slice", "start": 0.0, "end": 10.0}}, "segments": []any{},
|
|
})
|
|
if recorder.Code != http.StatusForbidden {
|
|
t.Fatalf("reviewer draft status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestCombinedAnnotationDraftRejectsAnnotatorWhoDidNotClaimTheItem(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
other := domain.UserRecord{ID: "other-draft-annotator", OrganizationID: domain.DefaultOrganizationID, Role: domain.UserRoleAnnotator, Status: domain.UserStatusActive}
|
|
if err := fixture.store.UpsertUser(fixture.ctx, other); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := fixture.store.UpsertProjectAnnotationMembership(fixture.ctx, domain.ProjectAnnotationMembershipRecord{ID: "other-draft-membership", OrganizationID: domain.DefaultOrganizationID, ProjectID: fixture.task.ProjectID, UserID: other.ID, AssignmentRole: domain.AnnotationRoleAnnotator}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
recorder := fixture.request(http.MethodPut, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/drafts", other, map[string]any{
|
|
"version": fixture.item.Version, "sliceSegments": []map[string]any{{"id": "slice", "start": 0.0, "end": 10.0}}, "segments": []any{},
|
|
})
|
|
if recorder.Code != http.StatusConflict || !bytes.Contains(recorder.Body.Bytes(), []byte("human_item_claim_required")) {
|
|
t.Fatalf("unassigned annotator draft status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestCombinedAnnotationDraftRejectsCrossSliceSemanticEvent(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
recorder := fixture.request(http.MethodPut, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/drafts", fixture.annotator, map[string]any{
|
|
"version": fixture.item.Version,
|
|
"sliceSegments": []map[string]any{
|
|
{"id": "slice-a", "start": 0.0, "end": 5.0},
|
|
{"id": "slice-b", "start": 5.0, "end": 10.0},
|
|
},
|
|
"segments": []map[string]any{{"id": "crossing", "labelId": "01", "label": "鲜食处理", "start": 4.5, "end": 5.5, "confidence": 1.0}},
|
|
})
|
|
if recorder.Code != http.StatusBadRequest || !bytes.Contains(recorder.Body.Bytes(), []byte("fully contained in exactly one submitted final slice")) {
|
|
t.Fatalf("cross-slice draft status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestCombinedSubmissionCanRequireEverySliceToBeCompleted(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
recorder := fixture.request(http.MethodPost, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/combined-submissions", fixture.annotator, map[string]any{
|
|
"version": fixture.item.Version, "requireSliceCompletion": true,
|
|
"sliceSegments": []map[string]any{{"id": "slice", "start": 0.0, "end": 10.0, "annotationStatus": "pending"}},
|
|
"segments": []any{},
|
|
})
|
|
if recorder.Code != http.StatusBadRequest || !bytes.Contains(recorder.Body.Bytes(), []byte("slice_annotation_pending")) {
|
|
t.Fatalf("incomplete combined submission status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
stored, _ := fixture.store.GetHumanItem(fixture.ctx, fixture.item.ID)
|
|
if stored == nil || stored.Version != fixture.item.Version || stored.CurrentStageID != domain.FanyuV58StageAnnotationCombined {
|
|
t.Fatalf("completion validation must not mutate item: %#v", stored)
|
|
}
|
|
}
|
|
|
|
func TestCombinedSubmissionSupportsImmediateAsynchronousResponse(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
payload := map[string]any{
|
|
"version": fixture.item.Version, "requireSliceCompletion": true,
|
|
"sliceSegments": []map[string]any{{"id": "slice", "start": 0.0, "end": 10.0, "annotationStatus": "empty_confirmed"}},
|
|
"segments": []any{},
|
|
}
|
|
encoded, _ := json.Marshal(payload)
|
|
request := httptest.NewRequest(http.MethodPost, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID+"/combined-submissions", bytes.NewReader(encoded))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
request.Header.Set("Prefer", "respond-async")
|
|
csrf := "combined-async-csrf"
|
|
request.AddCookie(&http.Cookie{Name: csrfCookieName, Value: csrf})
|
|
request.Header.Set(csrfHeaderName, csrf)
|
|
request = request.WithContext(context.WithValue(request.Context(), authContextKey{}, &authenticatedPrincipal{User: fixture.annotator, Organization: domain.OrganizationRecord{ID: domain.DefaultOrganizationID, Status: domain.OrganizationStatusActive}}))
|
|
recorder := httptest.NewRecorder()
|
|
fixture.handler.ServeHTTP(recorder, request)
|
|
if recorder.Code != http.StatusAccepted {
|
|
t.Fatalf("async combined submission status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
var response map[string]any
|
|
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response["status"] != "processing" || response["submissionId"] == "" {
|
|
t.Fatalf("async combined submission response=%#v", response)
|
|
}
|
|
}
|
|
|
|
func TestAnnotationTaskGetEnrichesLinkedHumanItemDisplay(t *testing.T) {
|
|
fixture := newCombinedDraftFixture(t)
|
|
recorder := fixture.request(http.MethodGet, "/api/plugins/annotation-qa/tasks/"+fixture.task.ID, fixture.annotator, nil)
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("task get status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
var response struct {
|
|
HumanItem domain.HumanItemRecord `json:"humanItem"`
|
|
}
|
|
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.HumanItem.Display == nil || response.HumanItem.Display.ProjectName != "泛宇草稿项目" || response.HumanItem.Display.WorkflowName != "持续标注工作流" || len(response.HumanItem.Display.CaptureDirectories) != 1 || response.HumanItem.Display.CaptureDirectories[0] != "capture-custom" {
|
|
t.Fatalf("linked human display=%#v", response.HumanItem.Display)
|
|
}
|
|
}
|