droboticflow/internal/api/deleted_author_rework_test.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"
}
}
}