forked from longtao.wu/droboticflow
377 lines
14 KiB
Go
377 lines
14 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
"fmt"
|
|
"net/http/httptest"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func inheritedReworkFixture(t *testing.T, n int) (combinedDraftFixture, []string) {
|
|
t.Helper()
|
|
t.Setenv("DELETED_ANNOTATOR_HANDOFF", "true")
|
|
f := newCombinedDraftFixture(t)
|
|
if err := f.store.UpsertOrganization(f.ctx, domain.OrganizationRecord{ID: f.item.OrganizationID, Name: "Test org", Status: domain.OrganizationStatusActive}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
other := f.annotator
|
|
other.ID = "new-worker"
|
|
other.CreatedAt = nowISO()
|
|
if err := f.store.UpsertUser(f.ctx, other); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.store.UpsertProjectMember(f.ctx, domain.ProjectMemberRecord{ID: "member-new", OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID, UserID: other.ID, SupplierID: other.SupplierID, Roles: []domain.AnnotationAssignmentRole{domain.AnnotationRoleAnnotator}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
old := f.annotator
|
|
old.ID = "deleted-author"
|
|
old.Status = domain.UserStatusDisabled
|
|
old.DeletedAt = nowISO()
|
|
if err := f.store.UpsertUser(f.ctx, old); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ids := []string{}
|
|
for i := 0; i < n; i++ {
|
|
task := f.task
|
|
task.ID = fmt.Sprintf("inherited-task-%d", i)
|
|
task.SupplierID = f.annotator.SupplierID
|
|
task.CurrentRevision = 1
|
|
task.Status = domain.AnnotationTaskStatusRework
|
|
if err := f.store.UpsertAnnotationTask(f.ctx, task); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
completeFixtureSourceValidation(t, f, task)
|
|
item := f.item
|
|
item.ID = fmt.Sprintf("inherited-item-%d", i)
|
|
item.LegacyTaskID = task.ID
|
|
item.Status = domain.HumanItemRework
|
|
item.AssignedUserID = ""
|
|
item.SupplierID = f.annotator.SupplierID
|
|
item.InheritedRework = true
|
|
item.ReviewRound = 1
|
|
item.CurrentRevision = 1
|
|
item.LatestAuthorUserID = old.ID
|
|
item.Subject.Payload = map[string]any{"source": "retained", "annotationDraft": map[string]any{"userId": old.ID, "marker": "never adopt this private draft"}}
|
|
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
baseline := domain.ReworkBaselineRecord{ID: store.ReworkBaselineID(item.ID, 1), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, ItemID: item.ID, Round: 1, Slices: []domain.SliceSegment{{ID: "s", Name: "正式切片", Start: 0, End: 10}}, Actions: []domain.AnnotationSegment{{ID: "a", Start: 0, End: 10, Description: "正式描述", Status: "described"}}, Problems: []domain.ReviewProblem{{ID: "p", Scope: "slice", SliceID: "s", Text: "原质检意见"}}}
|
|
if err := f.store.UpsertReworkBaseline(f.ctx, baseline); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ids = append(ids, item.ID)
|
|
}
|
|
return f, ids
|
|
}
|
|
|
|
func TestDeletedAuthorReworkFairCapacityAndFrozenContents(t *testing.T) {
|
|
f, ids := inheritedReworkFixture(t, 5)
|
|
s := &server{store: f.store}
|
|
before, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(ids[0], 1))
|
|
for i := 0; i < 3; i++ {
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
counts := map[string]int{}
|
|
pending := 0
|
|
for _, id := range ids {
|
|
item, _ := f.store.GetHumanItem(f.ctx, id)
|
|
if item.AssignedUserID == "" {
|
|
pending++
|
|
continue
|
|
}
|
|
counts[item.AssignedUserID]++
|
|
if item.AssignedUserID != f.annotator.ID && item.AssignedUserID != "new-worker" {
|
|
t.Fatal("wrong role/supplier assignment")
|
|
}
|
|
if item.Subject.Payload["annotationDraft"] != nil {
|
|
t.Fatal("inherited another person's private draft")
|
|
}
|
|
workspace := mapValue(item.Subject.Payload["annotationWorkspace"])
|
|
if workspace["userId"] != item.AssignedUserID {
|
|
t.Fatal("formal workspace not handed over")
|
|
}
|
|
actions := decodeMaterializationValue[domain.AnnotationSegment](workspace["segments"])
|
|
if len(actions) != 1 || actions[0].Description != "正式描述" {
|
|
t.Fatal("formal annotations lost")
|
|
}
|
|
}
|
|
if counts[f.annotator.ID] != 1 || counts["new-worker"] != 1 || pending != 3 {
|
|
t.Fatalf("tasks concentrated or lost: %#v pending=%d", counts, pending)
|
|
}
|
|
after, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(ids[0], 1))
|
|
if !reflect.DeepEqual(before, after) {
|
|
t.Fatal("formal quality comments were changed")
|
|
}
|
|
// Finishing one handoff releases only that person's inherited-work slot.
|
|
for _, id := range ids {
|
|
item, _ := f.store.GetHumanItem(f.ctx, id)
|
|
if item.AssignedUserID == f.annotator.ID {
|
|
item.AssignedUserID = ""
|
|
item.CurrentStageID = domain.FanyuV58StageQualityReview
|
|
item.Status = domain.HumanItemReady
|
|
item.Version++
|
|
if err := f.store.UpsertHumanItem(f.ctx, *item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assigned := 0
|
|
for _, id := range ids {
|
|
item, _ := f.store.GetHumanItem(f.ctx, id)
|
|
if item.AssignedUserID == f.annotator.ID {
|
|
assigned++
|
|
}
|
|
}
|
|
if assigned != 1 {
|
|
t.Fatal("newly available worker was not reused fairly")
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkDoesNotBlockOrdinaryClaim(t *testing.T) {
|
|
f, _ := inheritedReworkFixture(t, 2)
|
|
s := &server{store: f.store}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task := f.task
|
|
task.ID = "fresh-task"
|
|
if err := f.store.UpsertAnnotationTask(f.ctx, task); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
completeFixtureSourceValidation(t, f, task)
|
|
item := f.item
|
|
item.ID = "fresh-item"
|
|
item.LegacyTaskID = task.ID
|
|
item.AssignedUserID = ""
|
|
item.Status = domain.HumanItemReady
|
|
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r := f.request("POST", "/api/plugins/annotation-qa/random-claims", f.annotator, map[string]any{"projectId": f.item.ProjectID, "requestId": "fresh-after-inherited"})
|
|
if r.Code != 200 {
|
|
t.Fatal(r.Code, r.Body.String())
|
|
}
|
|
got, _ := f.store.GetHumanItem(f.ctx, item.ID)
|
|
if got.AssignedUserID != f.annotator.ID {
|
|
t.Fatal("inherited task was returned instead of new work")
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkDecisionDeletionRaceAndActiveAuthor(t *testing.T) {
|
|
for _, deleted := range []bool{false, true} {
|
|
t.Run(fmt.Sprint(deleted), func(t *testing.T) {
|
|
f, ids := inheritedReworkFixture(t, 1)
|
|
item, _ := f.store.GetHumanItem(f.ctx, ids[0])
|
|
item.InheritedRework = false
|
|
item.ReworkRoutingPending = true
|
|
item.LatestAuthorUserID = f.annotator.ID
|
|
item.AssignedUserID = f.annotator.ID
|
|
item.Status = domain.HumanItemClaimed
|
|
if err := f.store.UpsertHumanItem(f.ctx, *item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if deleted {
|
|
user := f.annotator
|
|
user.Status = domain.UserStatusDisabled
|
|
user.DeletedAt = nowISO()
|
|
if err := f.store.UpsertUser(f.ctx, user); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
s := &server{store: f.store}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
after, _ := f.store.GetHumanItem(f.ctx, item.ID)
|
|
if deleted {
|
|
if after.AssignedUserID != "new-worker" || !after.InheritedRework {
|
|
t.Fatal("late deletion left rework on deleted account")
|
|
}
|
|
} else {
|
|
if after.AssignedUserID != f.annotator.ID || after.InheritedRework || after.Version != item.Version {
|
|
t.Fatal("normal directed rework behavior changed")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkLegacyFormalRevisionFallback(t *testing.T) {
|
|
f, _ := inheritedReworkFixture(t, 0)
|
|
task := f.task
|
|
task.ID = "legacy-reviewed-task"
|
|
task.CurrentRevision = 1
|
|
task.SupplierID = f.annotator.SupplierID
|
|
task.Status = domain.AnnotationTaskStatusRework
|
|
if err := f.store.UpsertAnnotationTask(f.ctx, task); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
completeFixtureSourceValidation(t, f, task)
|
|
item := f.item
|
|
item.ID = "legacy-reviewed-item"
|
|
item.LegacyTaskID = task.ID
|
|
item.CurrentRevision = 1
|
|
item.ReviewRound = 1
|
|
item.InheritedRework = true
|
|
item.AssignedUserID = ""
|
|
item.SupplierID = task.SupplierID
|
|
item.Status = domain.HumanItemRework
|
|
item.LatestAuthorUserID = "deleted-author"
|
|
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.store.UpsertAnnotationRevision(f.ctx, domain.AnnotationRevisionRecord{ID: "legacy-formal", OrganizationID: item.OrganizationID, TaskID: task.ID, Revision: 1, Segments: []domain.AnnotationSegment{{ID: "formal", Start: 0, End: 10, Description: "旧正式描述"}}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.store.UpsertSliceRevision(f.ctx, domain.SliceRevisionRecord{ID: "legacy-slice", OrganizationID: item.OrganizationID, TaskID: task.ID, Revision: 1, Segments: []domain.SliceSegment{{ID: "formal-slice", Start: 0, End: 10}}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s := &server{store: f.store}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
after, _ := f.store.GetHumanItem(f.ctx, item.ID)
|
|
if after.AssignedUserID == "" {
|
|
t.Fatal("compatible formal history was not assigned")
|
|
}
|
|
actions := decodeMaterializationValue[domain.AnnotationSegment](mapValue(after.Subject.Payload["annotationWorkspace"])["segments"])
|
|
if len(actions) != 1 || actions[0].Description != "旧正式描述" {
|
|
t.Fatal("wrong legacy snapshot adopted")
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkNoEligibleRecipientRetainsContents(t *testing.T) {
|
|
f, ids := inheritedReworkFixture(t, 1)
|
|
for _, id := range []string{f.annotator.ID, "new-worker"} {
|
|
user, _ := f.store.GetUser(f.ctx, id)
|
|
user.Status = domain.UserStatusDisabled
|
|
if err := f.store.UpsertUser(f.ctx, *user); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
before, _ := f.store.GetHumanItem(f.ctx, ids[0])
|
|
s := &server{store: f.store}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
after, _ := f.store.GetHumanItem(f.ctx, ids[0])
|
|
if !reflect.DeepEqual(before, after) {
|
|
t.Fatal("unassignable task was cleared or forced onto another role")
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkKeepsActiveAuthorWithLegacyPoolSwitch(t *testing.T) {
|
|
t.Setenv("DELETED_ANNOTATOR_HANDOFF", "true")
|
|
t.Setenv("FANYU_REWORK_RETURN", "pool")
|
|
if reworkReturnMode() != "directed" {
|
|
t.Fatal("new policy allowed ordinary returns into public pool")
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkHonorsOrdinaryBufferCapacity(t *testing.T) {
|
|
f, ids := inheritedReworkFixture(t, 1)
|
|
batch, _ := f.store.GetHumanBatch(f.ctx, f.item.BatchID)
|
|
batch.ProcessingProfile = domain.ProcessingProfileRawHuman
|
|
if err := f.store.UpsertHumanBatch(f.ctx, *batch); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := f.store.SetSupplierProjectAuthorization(f.ctx, f.item.OrganizationID, f.item.ProjectID, f.annotator.SupplierID, true, f.admin.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, actor := range []string{f.annotator.ID, "new-worker"} {
|
|
owned := f.item
|
|
owned.ID = "capacity-" + actor
|
|
owned.AssignedUserID = actor
|
|
owned.SupplierID = f.annotator.SupplierID
|
|
if err := f.store.UpsertHumanItem(f.ctx, owned); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := f.store.AnnotationWorkBuffer(f.ctx, owned.OrganizationID, actor, owned.ProjectID, 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
s := &server{store: f.store}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
pending, _ := f.store.GetHumanItem(f.ctx, ids[0])
|
|
if pending.AssignedUserID != "" {
|
|
t.Fatal("inherited assignment exceeded ordinary pool capacity")
|
|
}
|
|
// Free the first worker's ordinary tasks; the second worker stays full.
|
|
owned, _ := f.store.ListHumanItems(f.ctx, f.item.OrganizationID, domain.HumanItemQuery{ActorUserID: f.annotator.ID})
|
|
for _, item := range owned {
|
|
if item.AssignedUserID == f.annotator.ID {
|
|
item.AssignedUserID = ""
|
|
item.CurrentStageID = domain.FanyuV58StageQualityReview
|
|
item.Version++
|
|
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
if err := s.dispatchDeletedAuthorReworks(f.ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assigned, _ := f.store.GetHumanItem(f.ctx, ids[0])
|
|
if assigned.AssignedUserID != f.annotator.ID {
|
|
t.Fatal("available qualified worker did not receive inherited rework", assigned.AssignedUserID)
|
|
}
|
|
}
|
|
|
|
func TestDeletedAuthorReworkRemainsClaimableAfterSubmission(t *testing.T) {
|
|
f, ids := inheritedReworkFixture(t, 1)
|
|
s := &server{store: f.store}
|
|
item, _ := f.store.GetHumanItem(f.ctx, ids[0])
|
|
annotationRequest := httptest.NewRequest("GET", "/", nil)
|
|
annotationRequest = annotationRequest.WithContext(context.WithValue(f.ctx, authContextKey{}, &authenticatedPrincipal{User: f.annotator, Organization: domain.OrganizationRecord{ID: item.OrganizationID, Status: domain.OrganizationStatusActive}}))
|
|
item.InheritedRework = false
|
|
item.ReworkRoutingPending = true
|
|
if s.canClaimHumanItem(f.ctx, annotationRequest, *item, domain.AnnotationRoleAnnotator) {
|
|
t.Fatal("pending routing advertised a manual claim")
|
|
}
|
|
item.ReworkRoutingPending = false
|
|
item.InheritedRework = true
|
|
acceptor := f.reviewer
|
|
acceptor.ID = "inherited-acceptor"
|
|
acceptor.Role = domain.UserRoleAcceptanceReviewer
|
|
if err := f.store.UpsertUser(f.ctx, acceptor); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.store.UpsertProjectMember(f.ctx, domain.ProjectMemberRecord{ID: "inherited-acceptor-member", OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: acceptor.ID, SupplierID: acceptor.SupplierID, Roles: []domain.AnnotationAssignmentRole{domain.AnnotationRoleAcceptanceReviewer}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, scenario := range []struct {
|
|
stage string
|
|
role domain.AnnotationAssignmentRole
|
|
actor domain.UserRecord
|
|
}{
|
|
{domain.FanyuV58StageQualityReview, domain.AnnotationRoleQualityReviewer, f.reviewer},
|
|
{"acceptance", domain.AnnotationRoleAcceptanceReviewer, acceptor},
|
|
} {
|
|
item.CurrentStageID = scenario.stage
|
|
item.Status = domain.HumanItemReady
|
|
r := httptest.NewRequest("GET", "/", nil)
|
|
r = r.WithContext(context.WithValue(f.ctx, authContextKey{}, &authenticatedPrincipal{User: scenario.actor, Organization: domain.OrganizationRecord{ID: item.OrganizationID, Status: domain.OrganizationStatusActive}}))
|
|
if !s.canClaimHumanItem(f.ctx, r, *item, scenario.role) {
|
|
t.Fatal("inherited marker blocked downstream reviewer", scenario.stage)
|
|
}
|
|
if scenario.role == domain.AnnotationRoleQualityReviewer {
|
|
item.LatestAuthorUserID = scenario.actor.ID
|
|
if s.canClaimHumanItem(f.ctx, r, *item, scenario.role) {
|
|
t.Fatal("self-review was allowed")
|
|
}
|
|
item.LatestAuthorUserID = "deleted-author"
|
|
}
|
|
}
|
|
}
|