forked from longtao.wu/droboticflow
219 lines
11 KiB
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)
|
|
}
|
|
}
|