droboticflow-new/internal/api/acceptance_authorization_test.go
d-robotics 74ea7f8274 🛡️ 03: deprecate task-scope review comments (ADR 0009)
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.
2026-10-14 19:02:29 +08:00

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())
}
}