droboticflow/internal/api/review_trace_test.go
2026-11-19 14:24:12 +08:00

289 lines
12 KiB
Go

package api
import (
"context"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"encoding/json"
"errors"
"net/http"
"strings"
"testing"
"time"
)
func TestReviewTraceExistingEvidenceAndMissingHistory(t *testing.T) {
for _, complete := range []bool{false, true} {
t.Run(map[bool]string{true: "complete", false: "legacy-gap"}[complete], func(t *testing.T) {
f := decisionFixture(t)
// A separate item makes the history boundary explicit rather than relying
// on fixture setup's events.
f.item.ID = "trace-item"
f.item.CurrentRevision = 3
f.item.LatestAuthorUserID = f.annotator.ID
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
add := func(id, kind, at string, payload map[string]any) {
t.Helper()
if err := f.store.AppendHumanEvent(f.ctx, domain.HumanEventRecord{ID: id, OrganizationID: f.item.OrganizationID, ItemID: f.item.ID, EventType: kind, ActorUserID: f.annotator.ID, CreatedAt: at, Payload: payload}); err != nil {
t.Fatal(err)
}
}
if complete {
add("created", "created", "2026-01-01T00:00:00Z", nil)
}
add("submit", "combined_submitted", "2026-01-02T00:00:00Z", map[string]any{"revision": 2, "private": "must-not-leak"})
add("reject", "combined_quality_rejected", "2026-01-03T00:00:00Z", map[string]any{"reviewedRevision": 2})
add("resubmit", "combined_submitted", "2026-01-04T00:00:00Z", map[string]any{"annotationRevision": 3})
before, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
res := reviewSessionRequest(f, http.MethodGet, "/api/human-items/"+f.item.ID+"/review-trace", f.reviewer, nil, nil)
if res.Code != 200 {
t.Fatalf("%d %s", res.Code, res.Body.String())
}
var trace reviewTrace
if err := json.Unmarshal(res.Body.Bytes(), &trace); err != nil {
t.Fatal(err)
}
if len(trace.Events) != 3 || trace.Events[0].Revision != 3 || trace.Events[0].Kind != "重新提交" || trace.Author != f.annotator.Name {
t.Fatalf("bad trace %+v", trace)
}
if complete {
if trace.Rejections == nil || *trace.Rejections != 1 || trace.FirstSubmittedAt != "2026-01-02T00:00:00Z" {
t.Fatalf("bad summary %+v", trace)
}
} else if trace.Rejections != nil || trace.FirstSubmittedAt != "" {
t.Fatal("invented legacy history")
}
if strings.Contains(res.Body.String(), "must-not-leak") || strings.Contains(res.Body.String(), "phone") {
t.Fatal("private data leaked")
}
after, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
if before.Version != after.Version || before.AssignedUserID != after.AssignedUserID {
t.Fatal("trace mutated item")
}
foreignItem := f.item
foreignItem.ID = "other-tenant-item"
foreignItem.OrganizationID = "other-org"
if err := f.store.UpsertHumanItem(f.ctx, foreignItem); err != nil {
t.Fatal(err)
}
denied := reviewSessionRequest(f, http.MethodGet, "/api/human-items/"+foreignItem.ID+"/review-trace", f.reviewer, nil, nil)
if denied.Code == 200 {
t.Fatal("cross-tenant trace exposed")
}
})
}
}
type unavailableTraceStore struct{ store.Store }
func (s unavailableTraceStore) ListHumanTraceSummaries(context.Context, string, []domain.HumanItemRecord) (map[string]domain.HumanTraceSummary, error) {
return nil, errors.New("synthetic metadata failure")
}
func TestReviewTraceSummaryFailureDoesNotHideTaskPool(t *testing.T) {
f := decisionFixture(t)
f.handler = NewHandler(unavailableTraceStore{f.store}, nil)
res := reviewSessionRequest(f, http.MethodGet, "/api/human-items?projectId="+f.item.ProjectID+"&pool=mine&trace=1", f.reviewer, nil, nil)
if res.Code != 200 || !strings.Contains(res.Body.String(), f.item.ID) {
t.Fatalf("metadata failure hid work: %d %s", res.Code, res.Body.String())
}
}
func TestReviewTraceAcceptanceProjectsOnlySelectedSource(t *testing.T) {
f := sharedAcceptanceFixture(t)
batch, err := f.store.GetHumanBatch(f.ctx, f.item.BatchID)
if err != nil {
t.Fatal(err)
}
f.item.CreatedAt = "2026-01-08T00:00:00Z"
f.item.AssignedUserID = f.reviewer.ID
f.item.CurrentRevision = 0
f.item.LatestAuthorUserID = ""
entries := f.item.Subject.Payload["items"].([]any)
for i, raw := range entries {
entry := raw.(map[string]any)
entry["runId"] = f.item.RunID
source := domain.HumanItemRecord{
ID: stringValue(entry["sourceHumanItemId"]), OrganizationID: f.item.OrganizationID,
ProjectID: f.item.ProjectID, WorkflowID: f.item.WorkflowID, RunID: f.item.RunID,
BatchID: batch.SourceBatchID, LegacyTaskID: stringValue(entry["taskId"]),
CurrentRevision: 9, LatestAuthorUserID: f.annotator.ID, SupplierID: f.annotator.SupplierID,
}
if i == 1 {
entry["annotationRevision"] = 4
}
if err := f.store.UpsertHumanItem(f.ctx, source); err != nil {
t.Fatal(err)
}
}
foreign := entries[0].(map[string]any)
entries = append(entries, map[string]any{"sourceHumanItemId": "wrong-batch", "taskId": foreign["taskId"], "runId": f.item.RunID})
f.item.Subject.Payload["items"] = entries
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
if err := f.store.UpsertHumanItem(f.ctx, domain.HumanItemRecord{
ID: "wrong-batch", OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID,
WorkflowID: f.item.WorkflowID, RunID: f.item.RunID, BatchID: "other", LegacyTaskID: stringValue(foreign["taskId"]),
}); err != nil {
t.Fatal(err)
}
add := func(itemID, kind, day string, revision int) {
t.Helper()
err := f.store.AppendHumanEvent(f.ctx, domain.HumanEventRecord{
ID: itemID + "-" + day, ItemID: itemID, OrganizationID: f.item.OrganizationID, EventType: kind,
CreatedAt: "2026-01-" + day + "T00:00:00Z", ActorUserID: f.annotator.ID,
Payload: map[string]any{"reviewedRevision": revision, "comment": "private comment"},
})
if err != nil {
t.Fatal(err)
}
}
add(f.item.ID, "created", "08", 0)
add(f.item.ID, "rejected", "09", 0)
add(f.item.ID, "created", "12", 0)
add("source-a", "created", "01", 0)
add("source-a", "combined_submitted", "02", 2)
add("source-a", "combined_quality_rejected", "03", 2)
add("source-a", "combined_submitted", "04", 3)
add("source-a", "combined_quality_approved", "05", 3)
add("source-a", "aggregate_acceptance_rejected", "09", 0)
add("source-a", "combined_quality_approved", "11", 3)
add("source-a", "combined_quality_approved", "13", 9)
add("source-b", "combined_submitted", "06", 4)
add("wrong-batch", "combined_quality_approved", "05", 7)
read := func(query string) reviewTrace {
t.Helper()
res := f.request(http.MethodGet, "/api/human-items/"+f.item.ID+"/review-trace"+query, f.reviewer, nil)
var trace reviewTrace
if res.Code != http.StatusOK || json.Unmarshal(res.Body.Bytes(), &trace) != nil {
t.Fatalf("trace status=%d body=%s", res.Code, res.Body.String())
}
if trace.AuthorID != "" || trace.Author != "" || trace.Supplier != "" || strings.Contains(res.Body.String(), "private comment") {
t.Fatalf("anonymous acceptance disclosed source metadata: %+v", trace)
}
return trace
}
a := read("?sourceItemId=source-a")
if a.Revision != 3 || a.FirstSubmittedAt != "2026-01-02T00:00:00Z" ||
a.QualityRejections == nil || *a.QualityRejections != 1 || a.Rejections == nil || *a.Rejections != 1 ||
len(a.Events) != 6 || a.Events[0].Kind != "质检通过" || a.Events[1].Kind != "验收退回" {
t.Fatalf("wrong source history: %+v", a)
}
for _, event := range a.Events {
if strings.HasPrefix(event.ID, "source-") && (event.Actor != "" || event.Revision == 9) {
t.Fatalf("source actor or newer revision exposed: %+v", event)
}
}
b := read("?sourceItemId=source-b")
if b.Revision != 4 || b.QualityRejections != nil || b.FirstSubmittedAt != "" || len(b.Events) != 2 {
t.Fatalf("wrong legacy source history: %+v", b)
}
for _, query := range []string{"", "?sourceItemId=wrong-batch", "?sourceItemId=unlisted"} {
got := read(query)
if got.Revision != 0 || got.QualityRejections != nil || len(got.Events) != 1 {
t.Fatalf("unexpected source read for %q: %+v", query, got)
}
}
}
type acceptanceAssemblyEventFailure struct {
store.Store
itemID string
err error
}
func (s acceptanceAssemblyEventFailure) AppendHumanEvent(ctx context.Context, event domain.HumanEventRecord) error {
if event.ItemID == s.itemID && event.EventType == "created" {
return s.err
}
return s.Store.AppendHumanEvent(ctx, event)
}
func TestReviewTraceAcceptanceReassemblySurvivesMissingCreatedEvent(t *testing.T) {
data, handler, quality, acceptance, source, aggregate := acceptanceProjectionFixture(t)
ctx := t.Context()
must := func(err error) {
t.Helper()
if err != nil {
t.Fatal(err)
}
}
batch, err := data.GetHumanBatch(ctx, source.BatchID)
must(err)
task, err := data.GetAnnotationTask(ctx, source.LegacyTaskID)
must(err)
path := "/api/human-items/" + aggregate.ID + "/review-trace"
read := func() reviewTrace {
t.Helper()
res := acceptanceProjectionRequest(handler, http.MethodGet, path, acceptance, nil)
var trace reviewTrace
if res.Code != http.StatusOK || json.Unmarshal(res.Body.Bytes(), &trace) != nil {
t.Fatalf("trace status=%d body=%s", res.Code, res.Body.String())
}
return trace
}
add := func(id, kind, at string, revision int) {
t.Helper()
must(data.AppendHumanEvent(ctx, domain.HumanEventRecord{
ID: id, ItemID: source.ID, OrganizationID: source.OrganizationID, EventType: kind,
ActorUserID: quality.ID, CreatedAt: at, Payload: map[string]any{"annotationRevision": revision},
}))
}
add("source-created", "created", "2026-01-01T00:00:00Z", 0)
add("source-original-submit", "combined_submitted", "2026-01-02T00:00:00Z", 1)
add("source-original-approval", "combined_quality_approved", "2026-01-03T00:00:00Z", 1)
if original := read(); original.Revision != 1 || len(original.Events) != 2 {
t.Fatalf("unexpected original trace: %+v", original)
}
aggregate.Status = domain.HumanItemRejected
must(data.UpsertHumanItem(ctx, *aggregate))
task.CurrentRevision = 2
must(data.UpsertAnnotationTask(ctx, *task))
source.Subject.Payload = map[string]any{"materialization": map[string]any{"artifactId": "reassembled-artifact", "revision": 2}}
must(data.UpsertHumanItem(ctx, *source))
must(data.UpsertAnnotationRevision(ctx, domain.AnnotationRevisionRecord{
ID: "reassembled-revision", OrganizationID: task.OrganizationID, TaskID: task.ID, Revision: 2,
}))
add("source-rework-rejected", "combined_quality_rejected", nowISO(), 1)
add("source-rework-submit", "combined_submitted", nowISO(), 2)
add("source-rework-approval", "combined_quality_approved", nowISO(), 2)
writeFailure := errors.New("injected failure after saving assembled acceptance payload")
assembly := &server{store: acceptanceAssemblyEventFailure{Store: data, itemID: aggregate.ID, err: writeFailure}}
if _, err := assembly.ensureFanyuV5PrePackageAcceptance(ctx, batch); !errors.Is(err, writeFailure) {
t.Fatalf("expected injected event failure, got %v", err)
}
// The restarted assembly sees a complete ready payload and returns without
// appending another event or overwriting the saved snapshots.
restarted := &server{store: data}
confirmed, err := restarted.ensureFanyuV5PrePackageAcceptance(ctx, batch)
must(err)
if confirmed {
t.Fatal("reassembly must leave the item awaiting acceptance")
}
persisted, err := data.GetHumanItem(ctx, aggregate.ID)
must(err)
if persisted.Status != domain.HumanItemReady || persisted.Version != aggregate.Version+1 {
t.Fatalf("reassembly was not persisted exactly once: %+v", persisted)
}
events, err := data.ListHumanTraceEvents(ctx, aggregate.OrganizationID, aggregate.ID)
must(err)
if len(events) != 1 || events[0].EventType != "created" || events[0].CreatedAt != aggregate.CreatedAt {
t.Fatalf("expected only the original assembly event: %+v", events)
}
later := parseISOTime(persisted.UpdatedAt).Add(time.Minute).Format(time.RFC3339Nano)
add("source-post-assembly", "combined_quality_approved", later, 3)
persisted.UpdatedAt = later
must(data.UpsertHumanItem(ctx, *persisted))
got := read()
if got.Revision != 2 || got.QualityRejections == nil || *got.QualityRejections != 1 ||
len(got.Events) != 5 || got.Events[0].ID != "source-rework-approval" ||
got.Events[1].ID != "source-rework-submit" || got.Events[2].ID != "source-rework-rejected" {
t.Fatalf("trace diverged from the saved assembly: %+v", got)
}
}