326 lines
12 KiB
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")
|
|
}
|
|
})
|
|
}
|
|
}
|