droboticflow/internal/api/annotation_random_claim_test.go

326 lines
12 KiB
Go

package api
import (
"droboticflow/internal/domain"
"encoding/json"
"fmt"
"net/http"
"sync"
"testing"
"time"
)
func randomClaimFixture(t *testing.T, n int, sourceReady ...bool) combinedDraftFixture {
f := newCombinedDraftFixture(t, "random-supplier")
if n > 0 {
completeFixtureSourceValidation(t, f, f.task)
}
supplier := domain.SupplierRecord{ID: "random-supplier", OrganizationID: domain.DefaultOrganizationID, Name: "Random vendor", Status: "active"}
if e := f.store.UpsertSupplier(f.ctx, supplier); e != nil {
t.Fatal(e)
}
for _, user := range []domain.UserRecord{f.annotator, f.reviewer} {
role := domain.AnnotationRoleAnnotator
if user.ID == f.reviewer.ID {
role = domain.AnnotationRoleQualityReviewer
}
if e := f.store.UpsertProjectMember(f.ctx, domain.ProjectMemberRecord{ID: "random-member-" + user.ID, OrganizationID: domain.DefaultOrganizationID, ProjectID: f.task.ProjectID, UserID: user.ID, SupplierID: supplier.ID, Roles: []domain.AnnotationAssignmentRole{role}}); e != nil {
t.Fatal(e)
}
}
// The original fixture is already owned, and must not be reassigned.
for i := 0; i < n; i++ {
task := f.task
task.ID = fmt.Sprintf("random-task-%d", i)
task.SupplierID = ""
task.AssignedUserID = ""
if e := f.store.UpsertAnnotationTask(f.ctx, task); e != nil {
t.Fatal(e)
}
if len(sourceReady) == 0 || sourceReady[0] {
completeFixtureSourceValidation(t, f, task)
}
item := f.item
item.ID = fmt.Sprintf("random-item-%d", i)
item.LegacyTaskID = task.ID
item.Status = domain.HumanItemReady
item.AssignedUserID = ""
item.SupplierID = ""
item.Version = 1
item.CurrentRevision = 0
if e := f.store.UpsertHumanItem(f.ctx, item); e != nil {
t.Fatal(e)
}
}
return f
}
// Tests outside the source validator use an explicit synthetic complete proof,
// rather than relying on the removed waiver for legacy/missing timeline jobs.
func completeFixtureSourceValidation(t *testing.T, f combinedDraftFixture, task domain.AnnotationTaskRecord) {
t.Helper()
if current, err := f.store.GetAnnotationIndexJob(f.ctx, task.ID); err == nil && current != nil && current.Status == "completed" && current.SourceFingerprint != "" {
return
}
if err := f.store.EnqueueAnnotationIndex(f.ctx, task); err != nil {
t.Fatal(err)
}
now := time.Now().UTC()
job, err := f.store.ClaimAnnotationIndex(f.ctx, "fixture-validation", now.Format(time.RFC3339Nano), now.Add(time.Minute).Format(time.RFC3339Nano))
if err != nil || job == nil || job.ID != task.ID {
t.Fatalf("expected fixture validation for %s: %+v %v", task.ID, job, err)
}
job.Status, job.SourceFingerprint = "completed", "fixture-full-source-"+task.ID
if ok, err := f.store.FinishAnnotationIndex(f.ctx, *job); err != nil || !ok {
t.Fatal("fixture validation completion", err)
}
}
func claimRandom(t *testing.T, f combinedDraftFixture, requestID string) domain.HumanItemRecord {
t.Helper()
r := f.request(http.MethodPost, "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": f.task.ProjectID, "requestId": requestID})
if r.Code != 200 {
t.Fatalf("claim %d: %s", r.Code, r.Body.String())
}
var out struct {
Item domain.HumanItemRecord `json:"item"`
}
if e := json.Unmarshal(r.Body.Bytes(), &out); e != nil {
t.Fatal(e)
}
return out.Item
}
func TestRandomClaimAtomicallyBindsAndReplaysWithoutSingleTaskLimit(t *testing.T) {
f := randomClaimFixture(t, 3)
first := claimRandom(t, f, "request-00000000001")
again := claimRandom(t, f, "request-00000000001")
second := claimRandom(t, f, "request-00000000002")
if first.ID == "" || first.ID != again.ID || first.Version != again.Version || second.ID == first.ID {
t.Fatalf("bad replay/new request: %s %s %s", first.ID, again.ID, second.ID)
}
if first.AssignedUserID != f.annotator.ID || first.SupplierID != "random-supplier" {
t.Fatal("claim ownership not bound")
}
task, _ := f.store.GetAnnotationTask(f.ctx, first.LegacyTaskID)
if task.AssignedUserID != first.AssignedUserID || task.SupplierID != first.SupplierID {
t.Fatal("legacy assignment/supplier differ")
}
batch, _ := f.store.GetHumanBatch(f.ctx, first.BatchID)
if batch.SupplierID != first.SupplierID {
t.Fatal("batch supplier differs")
}
events, _ := f.store.ListHumanEvents(f.ctx, first.OrganizationID, first.ID)
if len(events) != 1 {
t.Fatalf("duplicate audit events: %d", len(events))
}
owned, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
if owned.AssignedUserID != f.annotator.ID || owned.Version != f.item.Version {
t.Fatal("old owned task changed")
}
}
func TestRandomClaimConcurrentReplayAndNoDuplicateItem(t *testing.T) {
f := randomClaimFixture(t, 20)
var wg sync.WaitGroup
ids := make(chan string, 20)
errs := make(chan string, 20)
for i := 0; i < 20; i++ {
wg.Add(1)
go func() {
defer wg.Done()
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": f.task.ProjectID, "requestId": "concurrent-same-request"})
var out struct {
Item domain.HumanItemRecord `json:"item"`
}
json.Unmarshal(r.Body.Bytes(), &out)
if r.Code != 200 || out.Item.ID == "" {
errs <- r.Body.String()
}
ids <- out.Item.ID
}()
}
wg.Wait()
close(ids)
close(errs)
for e := range errs {
t.Fatal(e)
}
unique := map[string]bool{}
for id := range ids {
unique[id] = true
}
if len(unique) != 1 {
t.Fatalf("same request consumed %d tasks", len(unique))
}
ids = make(chan string, 12)
for i := 0; i < 12; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": f.task.ProjectID, "requestId": fmt.Sprintf("distinct-request-%04d", i)})
var out struct {
Item domain.HumanItemRecord `json:"item"`
}
json.Unmarshal(r.Body.Bytes(), &out)
ids <- out.Item.ID
}(i)
}
wg.Wait()
close(ids)
unique = map[string]bool{}
for id := range ids {
if id == "" || unique[id] {
t.Fatalf("duplicate/missing claim: %q", id)
}
unique[id] = true
}
}
func TestRandomClaimRejectsMissingProjectForeignScopeAndWrongRoles(t *testing.T) {
f := randomClaimFixture(t, 1)
for _, body := range []map[string]any{{"requestId": "request-00000000001"}, {"projectId": f.task.ProjectID, "requestId": "bad"}} {
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, body)
if r.Code < 400 {
t.Fatal("accepted invalid request")
}
}
for _, user := range []domain.UserRecord{f.admin, f.reviewer} {
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", user, map[string]any{"projectId": f.task.ProjectID, "requestId": "request-00000000001"})
if r.Code != 403 {
t.Fatalf("wrong role: %d", r.Code)
}
}
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": "foreign-project", "requestId": "request-00000000001"})
if r.Code != 403 {
t.Fatal("foreign project allowed")
}
}
func TestRandomClaimSkipsOtherSupplierAndReviewStages(t *testing.T) {
f := randomClaimFixture(t, 2)
other, _ := f.store.GetHumanItem(f.ctx, "random-item-0")
other.SupplierID = "someone-else"
f.store.UpsertHumanItem(f.ctx, *other)
review, _ := f.store.GetHumanItem(f.ctx, "random-item-1")
review.CurrentStageID = domain.FanyuV58StageQualityReview
f.store.UpsertHumanItem(f.ctx, *review)
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": f.task.ProjectID, "requestId": "request-00000000001"})
if r.Code != 200 {
t.Fatal(r.Body.String())
}
var out map[string]any
json.Unmarshal(r.Body.Bytes(), &out)
if out["code"] != "no_claimable_task" || out["item"] != nil {
t.Fatalf("unexpected result: %v", out)
}
}
func TestAnnotatorCannotReleaseOrSelectUnclaimedTaskButAdminStillCanRelease(t *testing.T) {
f := randomClaimFixture(t, 1)
r := f.request("POST", "/api/human-items/"+f.item.ID+"/release", f.annotator, map[string]any{"version": f.item.Version})
if r.Code != 403 {
t.Fatalf("release: %d %s", r.Code, r.Body.String())
}
for _, path := range []string{"/api/human-items/random-item-0", "/api/plugins/annotation-qa/tasks/random-task-0"} {
r := f.request("GET", path, f.annotator, nil)
if r.Code != 403 {
t.Fatalf("unclaimed preview %s: %d", path, r.Code)
}
}
r = f.request("POST", "/api/human-items/random-item-0/claim", f.annotator, map[string]any{"version": 1})
if r.Code != 403 {
t.Fatal("named claim bypassed random selection")
}
r = f.request("POST", "/api/human-items/"+f.item.ID+"/release", f.admin, map[string]any{"version": f.item.Version})
if r.Code != 200 {
t.Fatalf("admin release changed: %d %s", r.Code, r.Body.String())
}
}
func TestRandomClaimBlocksReviewerRelease(t *testing.T) {
f := randomClaimFixture(t, 0)
item := f.item
item.CurrentStageID = domain.FanyuV58StageQualityReview
item.AssignedUserID = f.reviewer.ID
f.store.UpsertHumanItem(f.ctx, item)
r := f.request("POST", "/api/human-items/"+item.ID+"/release", f.reviewer, map[string]any{"version": item.Version})
if r.Code != 403 {
t.Fatalf("reviewer release: %d %s", r.Code, r.Body.String())
}
}
func TestRandomClaimTwoAnnotatorsCompeteForOneItem(t *testing.T) {
f := randomClaimFixture(t, 1)
other := f.annotator
other.ID = "random-second-annotator"
if err := f.store.UpsertUser(f.ctx, other); err != nil {
t.Fatal(err)
}
if err := f.store.UpsertProjectMember(f.ctx, domain.ProjectMemberRecord{ID: "random-second-member", OrganizationID: other.OrganizationID, ProjectID: f.task.ProjectID, UserID: other.ID, SupplierID: "random-supplier", Roles: []domain.AnnotationAssignmentRole{domain.AnnotationRoleAnnotator}}); err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
results := make(chan string, 2)
for _, actor := range []domain.UserRecord{f.annotator, other} {
wg.Add(1)
go func(actor domain.UserRecord) {
defer wg.Done()
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", actor, map[string]any{"projectId": f.task.ProjectID, "requestId": "two-users-same-item"})
var out struct {
Item *domain.HumanItemRecord `json:"item"`
Code string `json:"code"`
}
if err := json.Unmarshal(r.Body.Bytes(), &out); err != nil || r.Code != 200 {
results <- "error"
return
}
if out.Item != nil {
results <- out.Item.AssignedUserID
} else if out.Code == "no_claimable_task" {
results <- "empty"
} else {
results <- "error"
}
}(actor)
}
wg.Wait()
close(results)
winners := 0
for result := range results {
if result == "error" {
t.Fatal("unexpected response")
}
if result != "empty" {
winners++
}
}
if winners != 1 {
t.Fatalf("expected exactly one owner, got %d", winners)
}
events, _ := f.store.ListHumanEvents(f.ctx, f.annotator.OrganizationID, "random-item-0")
if len(events) != 1 {
t.Fatalf("expected one claim event, got %d", len(events))
}
}
func TestRandomClaimDisabledSupplierAndBrokenTaskDoNotPartiallyAssign(t *testing.T) {
for _, mode := range []string{"disabled-supplier", "inconsistent-task"} {
t.Run(mode, func(t *testing.T) {
f := randomClaimFixture(t, 1)
if mode == "disabled-supplier" {
supplier, _ := f.store.GetSupplier(f.ctx, "random-supplier")
supplier.Status = "disabled"
f.store.UpsertSupplier(f.ctx, *supplier)
} else {
task, _ := f.store.GetAnnotationTask(f.ctx, "random-task-0")
task.SupplierID = "different-supplier"
f.store.UpsertAnnotationTask(f.ctx, *task)
}
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": f.task.ProjectID, "requestId": "must-not-assign-item"})
if mode == "disabled-supplier" && r.Code != 403 {
t.Fatalf("disabled supplier: %d", r.Code)
}
item, _ := f.store.GetHumanItem(f.ctx, "random-item-0")
batch, _ := f.store.GetHumanBatch(f.ctx, item.BatchID)
events, _ := f.store.ListHumanEvents(f.ctx, item.OrganizationID, item.ID)
if item.AssignedUserID != "" || item.Version != 1 || batch.SupplierID != "" || len(events) != 0 {
t.Fatal("failed claim changed ownership, batch or audit")
}
})
}
}