droboticflow/internal/api/annotation_sidebar_test.go
2026-10-17 13:11:00 +08:00

178 lines
6.7 KiB
Go

package api
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/url"
"reflect"
"testing"
"droboticflow/internal/domain"
"droboticflow/internal/store"
)
type sidebarReadCounter struct {
store.Store
batchPages, taskPages int
}
func (s *sidebarReadCounter) ListHumanBatchAccessRecords(ctx context.Context, org string, ids []string) ([]domain.HumanBatchRecord, error) {
s.batchPages++
return s.Store.ListHumanBatchAccessRecords(ctx, org, ids)
}
func (s *sidebarReadCounter) ListAnnotationTasksFiltered(ctx context.Context, org string, f store.AnnotationTaskFilter) ([]domain.AnnotationTaskRecord, error) {
s.taskPages++
return s.Store.ListAnnotationTasksFiltered(ctx, org, f)
}
func TestAnnotationSidebarMatchesLegacyReadsAndSharesMetadata(t *testing.T) {
f := newFanyuV5FourStageFixture(t, domain.FanyuV5StageSemanticAnnotation, domain.HumanItemInProgress, "annotator-v5", 1)
pool := f.request(http.MethodGet, "/api/human-items?pluginId=annotation-qa&pool=mine&annotationView=active&projectId="+f.task.ProjectID, f.annotator, nil)
tasks := f.request(http.MethodGet, "/api/plugins/annotation-qa/tasks?projectId="+f.task.ProjectID+"&ids="+f.task.ID, f.annotator, nil)
if pool.Code != 200 || tasks.Code != 200 {
t.Fatalf("legacy reads pool=%s tasks=%s", pool.Body, tasks.Body)
}
var wantPool struct {
Items []domain.HumanItemRecord `json:"items"`
}
var wantTasks struct {
Items []annotationTaskListRecord `json:"items"`
}
_ = json.Unmarshal(pool.Body.Bytes(), &wantPool)
_ = json.Unmarshal(tasks.Body.Bytes(), &wantTasks)
if len(wantPool.Items) != 1 || len(wantTasks.Items) != 1 {
t.Fatal("fixture must contain visible owned work")
}
counter := &sidebarReadCounter{Store: f.store}
f.handler = NewHandler(counter, nil)
response := f.request(http.MethodGet, "/api/plugins/annotation-qa/sidebar?projectId="+f.task.ProjectID+"&annotationView=active", f.annotator, nil)
if response.Code != 200 {
t.Fatalf("status=%d body=%s", response.Code, response.Body)
}
var got struct {
Items []domain.HumanItemRecord `json:"items"`
Tasks []annotationTaskListRecord `json:"tasks"`
}
if err := json.Unmarshal(response.Body.Bytes(), &got); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(got.Items, wantPool.Items) || !reflect.DeepEqual(got.Tasks, wantTasks.Items) {
t.Fatalf("sidebar must preserve legacy read result")
}
if counter.batchPages != 1 || counter.taskPages != 1 {
t.Fatalf("repeated list reads: batches=%d tasks=%d", counter.batchPages, counter.taskPages)
}
if denied := f.request(http.MethodGet, "/api/plugins/annotation-qa/sidebar?projectId="+f.task.ProjectID, f.quality, nil); denied.Code != 403 {
t.Fatalf("reviewer status=%d", denied.Code)
}
}
func TestAnnotationSidebarEmptyPageCannotExpandTaskQuery(t *testing.T) {
f := newFanyuV5FourStageFixture(t, domain.FanyuV5StageSemanticAnnotation, domain.HumanItemInProgress, "annotator-v5", 1)
counter := &sidebarReadCounter{Store: f.store}
f.handler = NewHandler(counter, nil)
response := f.request(http.MethodGet, "/api/plugins/annotation-qa/sidebar?projectId=missing&ids="+url.QueryEscape(f.task.ID), f.annotator, nil)
if response.Code != 200 {
t.Fatalf("status=%d body=%s", response.Code, response.Body)
}
var body struct {
Items []domain.HumanItemRecord `json:"items"`
Tasks []annotationTaskListRecord `json:"tasks"`
}
_ = json.Unmarshal(response.Body.Bytes(), &body)
if len(body.Items) != 0 || len(body.Tasks) != 0 || counter.taskPages != 0 {
t.Fatalf("empty scope queried tasks: %#v calls=%d", body, counter.taskPages)
}
}
func TestAnnotationSidebarPaginationSubmittedAndFreshAuthority(t *testing.T) {
f := newFanyuV5FourStageFixture(t, domain.FanyuV5StageSemanticAnnotation, domain.HumanItemInProgress, "annotator-v5", 1)
for i := 0; i < 3; i++ {
task := f.task
task.ID = fmt.Sprintf("sidebar-task-%d", i)
task.CreatedAt = fmt.Sprintf("2026-10-17T00:00:0%dZ", i)
item := f.item
item.ID = fmt.Sprintf("sidebar-item-%d", i)
item.LegacyTaskID = task.ID
item.CreatedAt = task.CreatedAt
item.Subject.ItemKey = task.ID
if i == 2 {
item.Status = domain.HumanItemSubmitted
item.AssignedUserID = ""
item.LatestAuthorUserID = f.annotator.ID
item.CurrentStageID = domain.FanyuV5StageSemanticReview
}
if err := f.store.UpsertAnnotationTask(f.ctx, task); err != nil {
t.Fatal(err)
}
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
t.Fatal(err)
}
}
type response struct {
Items []domain.HumanItemRecord `json:"items"`
Tasks []annotationTaskListRecord `json:"tasks"`
NextCursor string `json:"nextCursor"`
HasMore bool `json:"hasMore"`
}
read := func(view, cursor string) response {
t.Helper()
r := f.request(http.MethodGet, "/api/plugins/annotation-qa/sidebar?projectId="+f.task.ProjectID+"&limit=1&annotationView="+view+"&cursor="+url.QueryEscape(cursor), f.annotator, nil)
if r.Code != 200 {
t.Fatalf("sidebar=%d %s", r.Code, r.Body)
}
var got response
if err := json.Unmarshal(r.Body.Bytes(), &got); err != nil {
t.Fatal(err)
}
return got
}
first := read("active", "")
if len(first.Items) != 1 || len(first.Tasks) != 1 || !first.HasMore {
t.Fatalf("first=%+v", first)
}
next := read("active", first.NextCursor)
if len(next.Items) != 1 || len(next.Tasks) != 1 || first.Items[0].ID == next.Items[0].ID {
t.Fatalf("cursor repeats: %+v", next)
}
submitted := read("submitted", "")
if len(submitted.Items) != 1 || submitted.Items[0].ID != "sidebar-item-2" || len(submitted.Tasks) != 1 {
t.Fatalf("submitted=%+v", submitted)
}
if _, err := f.store.DeleteProjectMember(f.ctx, "project-member-legacy:"+f.task.ProjectID+":"+f.annotator.ID); err != nil {
t.Fatal(err)
}
revoked := read("active", "")
if len(revoked.Items) != 0 || len(revoked.Tasks) != 0 {
t.Fatalf("permission cached across requests: %+v", revoked)
}
}
func TestHumanListReadsReuseKeepsCurrentTaskJoinOrdering(t *testing.T) {
f := newFanyuV5FourStageFixture(t, domain.FanyuV5StageSemanticAnnotation, domain.HumanItemInProgress, "annotator-v5", 1)
server := &server{store: f.store}
old := f.item
newer := old
newer.ID = "newer-linked-item"
newer.BatchID = "newer-batch"
ctx, err := server.withHumanListReads(f.ctx, f.task.OrganizationID, f.task.ProjectID, []domain.HumanItemRecord{old})
if err != nil {
t.Fatal(err)
}
batch := f.batch
batch.ID = newer.BatchID
if err := f.store.UpsertHumanBatch(f.ctx, batch); err != nil {
t.Fatal(err)
}
ctx, err = server.withHumanListReads(ctx, f.task.OrganizationID, f.task.ProjectID, []domain.HumanItemRecord{newer, old})
if err != nil {
t.Fatal(err)
}
item, err := server.humanItemForLegacyTask(ctx, f.task)
if err != nil || item == nil || item.ID != newer.ID {
t.Fatalf("fresh task join ordering lost: item=%+v err=%v", item, err)
}
}