droboticflow/internal/api/acceptance_rework_baseline_test.go

219 lines
11 KiB
Go

package api
import (
"droboticflow/internal/domain"
"droboticflow/internal/store"
"encoding/json"
"strings"
"testing"
)
func TestAcceptanceForwardingPreservesSourceClockIdentityAndLegacy(t *testing.T) {
f := acceptanceReviewDraftFixture(t)
source := f.item
source.ID = "source-a"
source.CurrentStageID = domain.FanyuV58StageQualityReview
source.ReviewRound = 2
op := domain.ReviewOperation{ID: "acceptance-op", ItemID: f.item.ID, UserID: "acceptor", StageID: "prepackage_acceptance", ReviewRound: 3, ResultVersion: "frozen", Draft: domain.ReviewDraft{Problems: []domain.ReviewProblem{
{ID: "time", Scope: "timestamp", SourceItemID: "source-a", SliceID: "same", Text: "检查此帧", AtSeconds: 2, TimeBasis: "slice-seconds", ViewAnchor: &domain.ReviewViewAnchor{SourceItemID: "source-a", SliceID: "same", AtSeconds: 2, TimeBasis: "slice-seconds"}},
{ID: "foreign", Scope: "slice", SourceItemID: "source-b", SliceID: "same", Text: "另一来源"},
{ID: "legacy", Scope: "slice", SourceItemID: "source-a", SliceID: "missing", Text: "保留原文"},
}}}
b := acceptanceSourceBaseline(&op, source, f.item, 2)
if b == nil || len(b.Problems) != 1 || len(b.UnlocatedProblems) != 1 {
t.Fatalf("source partition: %+v", b)
}
p := b.Problems[0]
if p.AtSeconds != 12 || p.ViewAnchor.AtSeconds != 12 || p.SourceItemID != "" || p.ViewAnchor.SourceItemID != "" || p.Origin.ProblemID != "time" || p.Origin.UserID != "acceptor" || p.Origin.Round != 3 {
t.Fatalf("coordinates/provenance: %+v", p)
}
if b.UnlocatedProblems[0].Text != "保留原文" || b.UnlocatedProblems[0].SliceID != "missing" {
t.Fatal("legacy target invented")
}
if acceptanceSourceBaseline(&op, source, f.item, 2).Problems[0].ID != p.ID {
t.Fatal("retry identity changed")
}
if err := f.store.UpsertReworkBaseline(f.ctx, *b); err != nil {
t.Fatal(err)
}
s := &server{store: f.store}
next, err := s.qualityRejectionProblems(f.ctx, source, domain.ReviewDraft{Problems: []domain.ReviewProblem{{ID: "qc", Scope: "slice", SliceID: "same", Text: "质检补充"}}, Confirmations: []domain.ReviewConfirmation{{OpinionID: p.ID, Note: "保留前半段"}}})
if err != nil || len(next) != 2 || next[0].Origin.ProblemID != "time" || !strings.Contains(next[0].Text, "保留前半段") {
t.Fatalf("forward merge %v %+v", err, next)
}
_, err = f.store.CompareAndSwapReworkHandling(f.ctx, domain.ReworkHandlingRecord{ID: source.ID + ":acceptance-handling:" + op.ID, SkippedOpinionIDs: []string{"time"}}, 0)
if err != nil {
t.Fatal(err)
}
next, err = s.qualityRejectionProblems(f.ctx, source, domain.ReviewDraft{})
if err != nil || len(next) != 0 {
t.Fatalf("confirmed misreport forwarded: %v %+v", err, next)
}
raw, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(source.ID, 2))
if len(raw.Problems) != 1 {
t.Fatal("read mutated frozen evidence")
}
op.Draft.Problems = nil
op.Input = json.RawMessage(`{"comment":"旧版原文\n第二行"}`)
legacy := acceptanceSourceBaseline(&op, source, f.item, 2)
if len(legacy.UnlocatedProblems) != 1 || legacy.UnlocatedProblems[0].Text != "旧版原文\n第二行" {
t.Fatal("legacy text lost", legacy)
}
}
func TestAcceptanceForwardingCannotForgeProvenance(t *testing.T) {
problems, err := canonicalReviewProblems([]domain.ReviewProblem{{ID: "one", Scope: "slice", SliceID: "s", Text: "问题", Origin: &domain.ReviewProblemOrigin{UserID: "forged"}}}, []reviewTargetEvidence{{slices: []domain.SliceSegment{{ID: "s", Start: 0, End: 5}}}})
if err != nil || len(problems) != 1 || problems[0].Origin != nil {
t.Fatalf("untrusted origin %v %+v", err, problems)
}
}
func TestAcceptanceForwardingFormalQualityReturnRetainsBothAuthors(t *testing.T) {
for _, legacy := range []bool{false, true} {
t.Run(map[bool]string{false: "structured", true: "text-only"}[legacy], func(t *testing.T) {
f := reworkContractFixture(t)
f.item.ReviewRound = 1
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
original := domain.ReviewProblem{ID: "acceptance-original", Scope: "slice", SliceID: "left", Text: "验收问题", Origin: &domain.ReviewProblemOrigin{OperationID: "accept", ProblemID: "original", UserID: "acceptor", StageID: "prepackage_acceptance", Round: 3}}
b := domain.ReworkBaselineRecord{ID: store.ReworkBaselineID(f.item.ID, 1), OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID, ItemID: f.item.ID, Round: 1, StageID: domain.FanyuV58StageQualityReview, Problems: []domain.ReviewProblem{original}}
if legacy {
b.Problems = nil
b.UnlocatedProblems = []domain.ReviewProblem{original}
}
if err := f.store.UpsertReworkBaseline(f.ctx, b); err != nil {
t.Fatal(err)
}
reworkRejectRound(t, f, "forward", []map[string]any{{"id": "qc-new", "scope": "slice", "sliceId": "right", "text": "质检补充"}}, []map[string]any{{"opinionId": original.ID, "resolved": false, "note": "请先修正"}})
got, err := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(f.item.ID, 2))
if err != nil || got == nil {
t.Fatal(err)
}
if !strings.Contains(got.Comment, "验收问题") || !strings.Contains(got.Comment, "质检补充") || !strings.Contains(got.Comment, "请先修正") {
t.Fatalf("lost comment %s", got.Comment)
}
all := append(append([]domain.ReviewProblem{}, got.Problems...), got.UnlocatedProblems...)
if len(all) != 2 {
t.Fatal("duplicated/lost opinions", all)
}
for _, p := range all {
if p.ID == original.ID && (p.Origin == nil || p.Origin.UserID != "acceptor") {
t.Fatal("ownership lost")
}
}
item, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
if item.CurrentStageID != domain.FanyuV58StageAnnotationCombined || item.AssignedUserID != f.annotator.ID {
t.Fatal("return routing changed", item)
}
})
}
}
func TestAcceptanceForwardingReadsCompactHistoricalOperationWithoutWrites(t *testing.T) {
f := acceptanceReviewDraftFixture(t)
source := f.item
source.ID = "source-a"
source.CurrentStageID = domain.FanyuV58StageQualityReview
source.ReviewRound = 2
source.ReviewOperationID = "old-accept"
op := domain.ReviewOperation{ID: source.ReviewOperationID, ItemID: f.item.ID, OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID, Status: "completed", Decision: "rejected", StageID: "prepackage_acceptance", UserID: f.reviewer.ID, SourceItemIDs: []string{source.ID}, Draft: domain.ReviewDraft{Problems: []domain.ReviewProblem{{ID: "original", SourceItemID: source.ID, Scope: "timestamp", SliceID: "same", Text: "原验收点", TimeBasis: "slice-seconds", AtSeconds: 2}}}, Effects: []domain.ReviewDecisionEffect{{Item: &source}, {BeforeItem: &domain.HumanItemRecord{ID: f.item.ID, Version: 1}, Item: &f.item}}}
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, op, 0); !ok || e != nil {
t.Fatal(ok, e)
}
s := &server{store: f.store}
b, e := s.reworkBaselineForRound(f.ctx, source, 2)
if e != nil || b == nil || len(b.Problems) != 1 || b.Problems[0].AtSeconds != 12 {
t.Fatalf("compact history lost %v %+v", e, b)
}
stored, _ := f.store.GetReworkBaseline(f.ctx, store.ReworkBaselineID(source.ID, 2))
if stored != nil {
t.Fatal("compatibility read wrote baseline")
}
}
func TestAcceptanceHandlingFenceSurvivesServerRestartAndFailedDecision(t *testing.T) {
f := reworkContractFixture(t)
f.item.ReviewRound = 1
f.item.ReviewOperationID = "accept-return"
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
accept := domain.ReviewOperation{ID: "accept-return", OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID, ItemID: "aggregate", StageID: "prepackage_acceptance", Status: "completed", Decision: "rejected", SourceItemIDs: []string{f.item.ID}, Effects: []domain.ReviewDecisionEffect{{Item: &f.item}}, Draft: domain.ReviewDraft{Problems: []domain.ReviewProblem{{ID: "p", SourceItemID: f.item.ID, Scope: "slice", SliceID: "left", Text: "验收问题"}}}}
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, accept, 0); !ok || e != nil {
t.Fatal(ok, e)
}
b := domain.ReworkBaselineRecord{ID: store.ReworkBaselineID(f.item.ID, 1), ItemID: f.item.ID, Round: 1, Problems: []domain.ReviewProblem{{ID: "forwarded", Scope: "slice", SliceID: "left", Text: "验收问题", Origin: &domain.ReviewProblemOrigin{OperationID: accept.ID, ProblemID: "p", StageID: "prepackage_acceptance"}}}}
if e := f.store.UpsertReworkBaseline(f.ctx, b); e != nil {
t.Fatal(e)
}
op := domain.ReviewOperation{ID: "quality-return", Kind: "quality", Status: "prepared", Decision: "rejected", Draft: domain.ReviewDraft{ModelVersion: 2}}
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, op, 0); !ok || e != nil {
t.Fatal(ok, e)
}
s := &server{store: f.store}
if e := s.freezeAcceptanceHandling(f.ctx, f.item, &op); e != nil {
t.Fatal(e)
}
path := "/api/human-items/" + f.item.ID + "/acceptance-misreports"
payload := map[string]any{"operationId": accept.ID, "itemVersion": f.item.Version, "version": 1, "skippedOpinionIds": []string{"p"}}
f.handler = NewHandler(f.store, nil)
if r := f.request("PUT", path, f.reviewer, payload); r.Code != 409 {
t.Fatal("in-flight decision must fence handling after restart", r.Code, r.Body.String())
}
if e := (&server{store: f.store}).freezeAcceptanceHandling(f.ctx, f.item, &op); e != nil {
t.Fatal("retry must reuse fence", e)
}
h, _ := f.store.GetReworkHandling(f.ctx, f.item.ID+":acceptance-handling:"+accept.ID)
if h.Version != 1 {
t.Fatal("retry added a write", h)
}
op.Status = "failed_before_effects"
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, op, 1); !ok || e != nil {
t.Fatal(ok, e)
}
if r := f.request("PUT", path, f.reviewer, payload); r.Code != 200 {
t.Fatal("failed decision must allow editing", r.Code, r.Body.String())
}
op.ID = "quality-approve"
op.Status = "prepared"
op.Decision = "approved"
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, op, 0); !ok || e != nil {
t.Fatal(ok, e)
}
if e := s.freezeAcceptanceHandling(f.ctx, f.item, &op); e != nil {
t.Fatal("misreport state must be included in final validation", e)
}
payload["version"] = 3
payload["skippedOpinionIds"] = []string{}
if r := f.request("PUT", path, f.reviewer, payload); r.Code != 409 {
t.Fatal("approval must fence misreport revocation", r.Code, r.Body.String())
}
op.Status = "failed_before_effects"
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, op, 1); !ok || e != nil {
t.Fatal(ok, e)
}
op.ID = "racing-approval"
op.Status = "prepared"
if ok, e := f.store.CompareAndSwapReviewOperation(f.ctx, op, 0); !ok || e != nil {
t.Fatal(ok, e)
}
start := make(chan struct{})
decisionResult := make(chan error, 1)
mutationResult := make(chan int, 1)
go func() { <-start; decisionResult <- s.freezeAcceptanceHandling(f.ctx, f.item, &op) }()
go func() { <-start; mutationResult <- f.request("PUT", path, f.reviewer, payload).Code }()
close(start)
decisionError, mutationStatus := <-decisionResult, <-mutationResult
if mutationStatus != 200 && mutationStatus != 409 {
t.Fatal("unexpected concurrent response", mutationStatus)
}
if decisionError == nil && mutationStatus == 200 {
t.Fatal("approval and conflicting revocation both succeeded")
}
if decisionError != nil && mutationStatus != 200 {
t.Fatal("neither valid concurrent operation succeeded", decisionError, mutationStatus)
}
}