Server: reject NEW task-scope problems on draft PUT (409 review_task_scope_deprecated, ID-matched against stored entries; existing entries round-trip unchanged, full-replace semantics kept); formal-rejection flattening no longer emits 整体任务 lines or expands ProblemSliceIDs; rework-baseline reads hide task problems (read-only narrowing); workforce stats stop counting task scope. Frontend: remove task from composer scope lists and card cycle; hide stored task opinions in rework banner/soft reminder/rail, QC panel groups and history, acceptance source projection, stats panel rows, frozen-comment displays (stripTaskOpinionLines); submit/approve gates count visible problems only; stats panel documents the 2026-10-14 scope switch. Data untouched: no migration, no deletion, audit trail intact.
368 lines
17 KiB
Go
368 lines
17 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"testing"
|
|
|
|
"droboticflow/internal/domain"
|
|
)
|
|
|
|
func sharedAcceptanceFixture(t *testing.T) combinedDraftFixture {
|
|
t.Helper()
|
|
f := acceptanceReviewDraftFixture(t)
|
|
oldSupplier := f.reviewer.SupplierID
|
|
f.reviewer.ID = "shared-reviewer"
|
|
f.reviewer.SupplierID = "shared-supplier"
|
|
f.reviewer.AcceptanceAccessMode = "managed"
|
|
if err := f.store.UpsertSupplier(f.ctx, domain.SupplierRecord{ID: f.reviewer.SupplierID, OrganizationID: f.item.OrganizationID, Status: "active"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.store.UpsertUser(f.ctx, f.reviewer); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, true, 0, f.admin.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
batch, _ := f.store.GetHumanBatch(f.ctx, f.item.BatchID)
|
|
source := *batch
|
|
source.ID = "shared-source"
|
|
source.Stages = domain.DefaultFanyuV58HumanStages()
|
|
source.RequirePrePackageAcceptance = true
|
|
source.ProcessingProfile = domain.ProcessingProfileRawHuman
|
|
if err := f.store.UpsertHumanBatch(f.ctx, source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
batch.SourceBatchID = source.ID
|
|
batch.ProcessingProfile = domain.ProcessingProfileRawHuman
|
|
if err := f.store.UpsertHumanBatch(f.ctx, *batch); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
f.item.SupplierID = oldSupplier
|
|
f.item.AssignedUserID = ""
|
|
f.item.Status = domain.HumanItemReady
|
|
f.item.ClaimedAt = ""
|
|
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return f
|
|
}
|
|
func TestSharedAcceptanceAPIAndRevocation(t *testing.T) {
|
|
f := sharedAcceptanceFixture(t)
|
|
path := "/api/suppliers/" + f.reviewer.SupplierID + "/acceptance-authorization"
|
|
manager := domain.UserRecord{ID: "manager", OrganizationID: f.item.OrganizationID, SupplierID: f.reviewer.SupplierID, Role: domain.UserRoleSupplierManager, Status: domain.UserStatusActive}
|
|
_ = f.store.UpsertUser(f.ctx, manager)
|
|
for _, tc := range []struct {
|
|
method string
|
|
user domain.UserRecord
|
|
want int
|
|
}{{"GET", manager, 200}, {"PUT", manager, 403}, {"GET", f.annotator, 403}} {
|
|
r := f.request(tc.method, path, tc.user, map[string]any{"enabled": false, "version": 1})
|
|
if r.Code != tc.want {
|
|
t.Fatalf("permission %s %d %s", tc.method, r.Code, r.Body.String())
|
|
}
|
|
}
|
|
projects := f.request("GET", "/api/projects", f.reviewer, nil)
|
|
if projects.Code != 200 || !jsonContains(projects.Body.String(), f.item.ProjectID) {
|
|
t.Fatalf("projects %d %s", projects.Code, projects.Body.String())
|
|
}
|
|
listed := f.request("GET", "/api/human-items?pluginId=annotation-qa&pool=available", f.reviewer, nil)
|
|
if listed.Code != 200 || !jsonContains(listed.Body.String(), `"canClaim":true`) {
|
|
t.Fatalf("shared pool must expose server claim capability: %d %s", listed.Code, listed.Body.String())
|
|
}
|
|
read := f.request("GET", "/api/human-items/"+f.item.ID, f.reviewer, nil)
|
|
if read.Code != 200 {
|
|
t.Fatalf("cross-project read %d %s", read.Code, read.Body.String())
|
|
}
|
|
claim := f.request("POST", "/api/human-items/"+f.item.ID+"/claim", f.reviewer, map[string]any{"version": f.item.Version})
|
|
if claim.Code != 200 {
|
|
t.Fatalf("claim %d %s", claim.Code, claim.Body.String())
|
|
}
|
|
stored, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
f.item = *stored
|
|
if !stored.AcceptanceClaim.Matches(*stored, f.reviewer) {
|
|
t.Fatal("claim receipt missing")
|
|
}
|
|
_, headers := openReviewDraftSession(t, f)
|
|
revoke := f.request("PUT", path, f.admin, map[string]any{"enabled": false, "version": 1})
|
|
if revoke.Code != 200 {
|
|
t.Fatalf("revoke %d %s", revoke.Code, revoke.Body.String())
|
|
}
|
|
read = f.request("GET", "/api/human-items/"+f.item.ID, f.reviewer, nil)
|
|
if read.Code != 200 {
|
|
t.Fatalf("owned item lost after revoke: %d %s", read.Code, read.Body.String())
|
|
}
|
|
session, _ := f.store.GetReviewSession(f.ctx, reviewSessionKey(f.item))
|
|
save := reviewSessionRequest(f, "PUT", "/api/human-items/"+f.item.ID+"/review-draft", f.reviewer, map[string]any{"version": 0, "resultVersion": session.ResultVersion, "operationId": "save-revoked", "problems": []map[string]any{{"id": "one", "scope": "slice", "sourceItemId": "source-a", "sliceId": "same", "text": "检查切片", "atSeconds": 1}}}, headers)
|
|
if save.Code != 200 {
|
|
t.Fatalf("draining draft %d %s", save.Code, save.Body.String())
|
|
}
|
|
replay := reviewSessionRequest(f, "PUT", "/api/human-items/"+f.item.ID+"/review-draft", f.reviewer, map[string]any{"version": 0, "resultVersion": session.ResultVersion, "operationId": "save-revoked", "problems": []map[string]any{{"id": "one", "scope": "slice", "sourceItemId": "source-a", "sliceId": "same", "text": "检查切片", "atSeconds": 1}}}, headers)
|
|
if replay.Code != 200 {
|
|
t.Fatalf("save retry %d %s", replay.Code, replay.Body.String())
|
|
}
|
|
other := f.item
|
|
other.ID = "other"
|
|
other.AssignedUserID = ""
|
|
other.ClaimedAt = ""
|
|
other.Status = domain.HumanItemReady
|
|
_ = f.store.UpsertHumanItem(f.ctx, other)
|
|
denied := f.request("POST", "/api/human-items/other/claim", f.reviewer, map[string]any{"version": other.Version})
|
|
if denied.Code != 403 {
|
|
t.Fatalf("revoked new claim %d", denied.Code)
|
|
}
|
|
// Reopened rounds and internal/foreign records never inherit shared access.
|
|
_, _ = f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, true, 2, f.admin.ID)
|
|
for _, kind := range []string{"internal", "foreign", "annotation"} {
|
|
v := other
|
|
v.ID = kind
|
|
switch kind {
|
|
case "internal":
|
|
v.ProcessingScope = "internal"
|
|
case "foreign":
|
|
v.OrganizationID = "other-org"
|
|
case "annotation":
|
|
v.CurrentStageID = "quality_review"
|
|
}
|
|
_ = f.store.UpsertHumanItem(f.ctx, v)
|
|
out := f.request("GET", "/api/human-items/"+v.ID, f.reviewer, nil)
|
|
if out.Code != 403 && out.Code != 404 {
|
|
t.Fatalf("scope leak %s %d", kind, out.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSharedAcceptanceAllProjectContinuation(t *testing.T) {
|
|
f := sharedAcceptanceFixture(t)
|
|
second := f.item
|
|
second.ID = "project-two-item"
|
|
second.ProjectID = "project-two"
|
|
second.CreatedAt = "2000-01-01T00:00:00Z"
|
|
_ = f.store.UpsertProject(f.ctx, domain.ProjectRecord{ID: second.ProjectID, OrganizationID: second.OrganizationID})
|
|
_ = f.store.UpsertHumanItem(f.ctx, second)
|
|
body := map[string]any{"action": "start", "stage": "acceptance", "scope": "all", "pageId": "all-page", "generation": 0}
|
|
out := f.request("POST", "/api/review-continuation", f.reviewer, body)
|
|
result := continuationResult(t, out)
|
|
if result.Item == nil || result.Item.ID != second.ID {
|
|
t.Fatalf("all projects did not select oldest: %s", out.Body.String())
|
|
}
|
|
body["action"] = "pause"
|
|
body["generation"] = result.Generation
|
|
if r := f.request("POST", "/api/review-continuation", f.reviewer, body); r.Code != 200 {
|
|
t.Fatal(r.Body.String())
|
|
}
|
|
body = map[string]any{"action": "start", "stage": "acceptance", "scope": "project", "projectId": f.item.ProjectID, "pageId": "project-page", "generation": 0}
|
|
out = f.request("POST", "/api/review-continuation", f.reviewer, body)
|
|
result = continuationResult(t, out)
|
|
if result.Item == nil || result.Item.ID != f.item.ID {
|
|
t.Fatalf("specific project leaked: %s", out.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestSupplierAcceptanceCreationGate(t *testing.T) {
|
|
f := newCombinedDraftFixture(t)
|
|
supplier := f.annotator.SupplierID
|
|
endpoint := "/api/suppliers/" + supplier + "/acceptance-authorization"
|
|
payload := map[string]any{"name": "new reviewer", "phone": "13900999001", "password": "local-test-password", "supplierId": supplier, "role": "acceptance_reviewer"}
|
|
denied := f.request(http.MethodPost, "/api/users", f.admin, payload)
|
|
if denied.Code != 403 {
|
|
t.Fatalf("admin bypass %d %s", denied.Code, denied.Body.String())
|
|
}
|
|
grant := f.request(http.MethodPut, endpoint, f.admin, map[string]any{"enabled": true, "version": 0})
|
|
if grant.Code != 200 {
|
|
t.Fatalf("default supplier grant %d %s", grant.Code, grant.Body.String())
|
|
}
|
|
created := f.request(http.MethodPost, "/api/users", f.admin, payload)
|
|
if created.Code != 201 {
|
|
t.Fatalf("create %d %s", created.Code, created.Body.String())
|
|
}
|
|
var user domain.UserRecord
|
|
_ = json.Unmarshal(created.Body.Bytes(), &user)
|
|
if user.AcceptanceAccessMode != "managed" {
|
|
t.Fatal("new account is legacy")
|
|
}
|
|
legacy := f.reviewer
|
|
legacy.Role = domain.UserRoleAcceptanceReviewer
|
|
_ = f.store.UpsertUser(f.ctx, legacy)
|
|
_ = f.request(http.MethodPut, endpoint, f.admin, map[string]any{"enabled": false, "version": 1})
|
|
edit := f.request(http.MethodPut, "/api/users/"+legacy.ID, f.admin, map[string]any{"name": "renamed legacy"})
|
|
if edit.Code != 200 {
|
|
t.Fatalf("legacy profile edit %d %s", edit.Code, edit.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestSharedAcceptanceRevokedDecisionRecovery(t *testing.T) {
|
|
for _, decision := range []string{"approved", "rejected"} {
|
|
t.Run(decision, func(t *testing.T) {
|
|
f := sharedAcceptanceFixture(t)
|
|
batch, _ := f.store.GetHumanBatch(f.ctx, f.item.BatchID)
|
|
f.item.ID = fanyuV5PrePackageAcceptanceItemID(batch.SourceBatchID)
|
|
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, id := range []string{"source-a", "source-b"} {
|
|
source := f.item
|
|
source.ID, source.BatchID, source.CurrentStageID = id, batch.SourceBatchID, domain.FanyuV58StageQualityReview
|
|
source.Status, source.ReviewRound, source.Version = domain.HumanItemAccepted, 4, 10
|
|
source.LegacyTaskID = "task-" + id
|
|
source.AcceptedAt = nowISO()
|
|
if err := f.store.UpsertHumanItem(f.ctx, source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
task := f.task
|
|
task.ID, task.Status, task.SupplierID = source.LegacyTaskID, domain.AnnotationTaskStatusAccepted, source.SupplierID
|
|
if err := f.store.UpsertAnnotationTask(f.ctx, task); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
snapshot, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
before, _ := json.Marshal(snapshot.Subject.Payload)
|
|
base := "/api/human-items/" + f.item.ID
|
|
claim := f.request("POST", base+"/claim", f.reviewer, map[string]any{"version": f.item.Version})
|
|
if claim.Code != 200 {
|
|
t.Fatal(claim.Body.String())
|
|
}
|
|
stored, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
f.item = *stored
|
|
version, headers := openReviewDraftSession(t, f)
|
|
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
f.handler = NewHandler(&interruptedReviewStore{Store: f.store, failure: "after-human-write"}, nil)
|
|
payload := map[string]any{"version": f.item.Version, "decision": decision, "comment": "需要核对", "reasonCodes": []string{"batch_problem"}, "operationId": "revoked-decision", "draftVersion": 0, "resultVersion": version}
|
|
first := reviewSessionRequest(f, "POST", base+"/decisions", f.reviewer, payload, headers)
|
|
if first.Code != 202 {
|
|
t.Fatalf("interrupted %d %s", first.Code, first.Body.String())
|
|
}
|
|
f.handler = NewHandler(f.store, nil)
|
|
retry := f.request("POST", base+"/review-operations/revoked-decision/reconcile", f.reviewer, nil)
|
|
if retry.Code != 200 {
|
|
t.Fatalf("reconcile %d %s", retry.Code, retry.Body.String())
|
|
}
|
|
replay := reviewSessionRequest(f, "POST", base+"/decisions", f.reviewer, payload, headers)
|
|
if replay.Code != 200 {
|
|
t.Fatalf("replay %d %s", replay.Code, replay.Body.String())
|
|
}
|
|
current, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
after, _ := json.Marshal(current.Subject.Payload)
|
|
if string(before) != string(after) || current.SupplierID != f.item.SupplierID {
|
|
t.Fatalf("annotation/production ownership changed: before=%s after=%s suppliers=%s/%s", before, after, current.SupplierID, f.item.SupplierID)
|
|
}
|
|
for _, id := range []string{"source-a", "source-b"} {
|
|
source, _ := f.store.GetHumanItem(f.ctx, id)
|
|
if source.SupplierID != f.item.SupplierID {
|
|
t.Fatal("rejection changed supplier")
|
|
}
|
|
if decision == "rejected" && (source.CurrentStageID != domain.FanyuV58StageQualityReview || source.Status != domain.HumanItemSubmitted || source.ReviewRound != 5) {
|
|
t.Fatalf("wrong return route %+v", source)
|
|
}
|
|
}
|
|
current.ReviewRound++
|
|
current.Status = domain.HumanItemReady
|
|
current.AssignedUserID = ""
|
|
current.ClaimedAt = ""
|
|
_ = f.store.UpsertHumanItem(f.ctx, *current)
|
|
denied := f.request("POST", base+"/claim", f.reviewer, map[string]any{"version": current.Version})
|
|
if denied.Code != 403 {
|
|
t.Fatalf("next round inherited access: %d", denied.Code)
|
|
}
|
|
oldReceipt := f.request("GET", base+"/review-operations/revoked-decision", f.reviewer, nil)
|
|
if oldReceipt.Code != 200 {
|
|
t.Fatalf("lost historical receipt %d", oldReceipt.Code)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSharedAcceptanceLegacyScopeAndPageTakeover(t *testing.T) {
|
|
t.Run("legacy scope stays unchanged", func(t *testing.T) {
|
|
f := acceptanceReviewDraftFixture(t)
|
|
own := f.request("GET", "/api/human-items/"+f.item.ID, f.reviewer, nil)
|
|
if own.Code != 200 {
|
|
t.Fatalf("legacy own scope: %d %s", own.Code, own.Body.String())
|
|
}
|
|
foreign := f.item
|
|
foreign.ID, foreign.ProjectID, foreign.SupplierID = "outside-legacy", "outside-project", "outside-supplier"
|
|
foreign.AssignedUserID = ""
|
|
if err := f.store.UpsertHumanItem(f.ctx, foreign); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
denied := f.request("GET", "/api/human-items/"+foreign.ID, f.reviewer, nil)
|
|
if denied.Code != 403 {
|
|
t.Fatalf("legacy scope expanded: %d %s", denied.Code, denied.Body.String())
|
|
}
|
|
grant, err := f.store.GetSupplierAcceptanceAuthorization(f.ctx, f.reviewer.OrganizationID, f.reviewer.SupplierID)
|
|
if err != nil || grant.Enabled {
|
|
t.Fatalf("legacy migration enabled shared pool: %v", err)
|
|
}
|
|
})
|
|
t.Run("revoked owner can take over current page only", func(t *testing.T) {
|
|
f := sharedAcceptanceFixture(t)
|
|
base := "/api/human-items/" + f.item.ID
|
|
if r := f.request("POST", base+"/claim", f.reviewer, map[string]any{"version": f.item.Version}); r.Code != 200 {
|
|
t.Fatal(r.Body.String())
|
|
}
|
|
item, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
f.item = *item
|
|
_, headers := openReviewDraftSession(t, f)
|
|
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
readOnly := f.request("POST", base+"/review-session", f.reviewer, map[string]any{"action": "acquire", "pageId": "other-page", "generation": 0})
|
|
if readOnly.Code != 200 || !jsonContains(readOnly.Body.String(), `"writable":false`) {
|
|
t.Fatal(readOnly.Body.String())
|
|
}
|
|
takeover := f.request("POST", base+"/review-session", f.reviewer, map[string]any{"action": "takeover", "pageId": "other-page", "generation": 0})
|
|
if takeover.Code != 200 || !jsonContains(takeover.Body.String(), `"writable":true`) {
|
|
t.Fatal(takeover.Body.String())
|
|
}
|
|
stale := reviewSessionRequest(f, "PUT", base+"/review-draft", f.reviewer, map[string]any{"version": 0, "operationId": "stale-page", "problems": []any{}}, headers)
|
|
if stale.Code != 409 {
|
|
t.Fatalf("old page still writes: %d %s", stale.Code, stale.Body.String())
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestSharedAcceptanceAdminAssignmentAndIsolation(t *testing.T) {
|
|
f := sharedAcceptanceFixture(t)
|
|
// Ordinary run access remains project-scoped even when bound evidence is shared.
|
|
if err := f.store.UpsertRun(f.ctx, domain.RunRecord{ID: "shared-evidence-run", OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out := f.request("GET", "/api/runs/shared-evidence-run", f.reviewer, nil)
|
|
if out.Code != 403 {
|
|
t.Fatalf("generic run access expanded: %d %s", out.Code, out.Body.String())
|
|
}
|
|
// A supplier manager receives no shared business access from the switch.
|
|
manager := f.reviewer
|
|
manager.ID, manager.Role = "shared-manager", domain.UserRoleSupplierManager
|
|
if err := f.store.UpsertUser(f.ctx, manager); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out = f.request("GET", "/api/human-items/"+f.item.ID, manager, nil)
|
|
if out.Code != 403 {
|
|
t.Fatalf("supplier manager expanded: %d %s", out.Code, out.Body.String())
|
|
}
|
|
// Admin assignment uses the same durable receipt as ordinary/continuous claims.
|
|
out = f.request("PATCH", "/api/human-items/"+f.item.ID+"/assignment", f.admin, map[string]any{"version": f.item.Version, "assignedUserId": f.reviewer.ID})
|
|
if out.Code != 200 {
|
|
t.Fatalf("assign shared reviewer: %d %s", out.Code, out.Body.String())
|
|
}
|
|
assigned, err := f.store.GetHumanItem(f.ctx, f.item.ID)
|
|
if err != nil || !assigned.AcceptanceClaim.Matches(*assigned, f.reviewer) || assigned.SupplierID != f.item.SupplierID {
|
|
t.Fatalf("assignment lost receipt/ownership: %v", err)
|
|
}
|
|
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
other := f.item
|
|
other.ID = "cannot-assign-after-revoke"
|
|
if err := f.store.UpsertHumanItem(f.ctx, other); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out = f.request("PATCH", "/api/human-items/"+other.ID+"/assignment", f.admin, map[string]any{"version": other.Version, "assignedUserId": f.reviewer.ID})
|
|
if out.Code != 400 {
|
|
t.Fatalf("admin bypassed revoked authorization: %d %s", out.Code, out.Body.String())
|
|
}
|
|
}
|