droboticflow-new/internal/api/slice_usability_http_test.go

330 lines
15 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package api
import (
"encoding/json"
"net/http"
"strings"
"testing"
"droboticflow/internal/domain"
)
func TestSliceDispositionNamesAreExclusiveAndUndoRestoresSavedName(t *testing.T) {
f := sliceRestorationFixture(t)
body := dispositionFixturePayload(t, f)
body.SliceSegments[1].Name = "已命名切片"
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
save := func(payload any) combinedAnnotationDraftInput {
t.Helper()
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, payload)
if r.Code != 200 {
t.Fatalf("disposition: %d %s", r.Code, r.Body.String())
}
item, workspace := readSliceRestoration(t, f)
body.combinedAnnotationDraftInput = workspace
body.Version = item.Version
return workspace
}
saved := save(body)
if saved.SliceSegments[1].Name != "" {
t.Fatal("discard retained a normal slice name")
}
body.Disposition = "keep"
saved = save(body)
if saved.SliceSegments[1].Name != "" {
t.Fatal("ordinary restore retained a normal slice name")
}
body.SliceSegments[1].Name = "重命名切片"
body.Disposition = "discard"
save(body)
body.Disposition = "keep"
raw, _ := json.Marshal(body)
var replay map[string]any
json.Unmarshal(raw, &replay)
replay["restorePreviousName"] = true
saved = save(replay)
if saved.SliceSegments[1].Name != "重命名切片" {
t.Fatalf("undo lost trusted name: %+v", saved.SliceSegments[1])
}
if len(saved.Segments) != 1 || saved.Segments[0].Description != "old text" {
t.Fatal("undo lost trusted action evidence")
}
}
func TestSliceResetKeepsPartitionWithoutRevivingArchivedActions(t *testing.T) {
f := sliceRestorationFixture(t)
body := dispositionFixturePayload(t, f)
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, prior := readSliceRestoration(t, f)
item.Subject.Payload["sliceWorkflow"] = map[string]any{"phase": "annotate", "status": "completed", "revision": 2}
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
t.Fatal(err)
}
// Ticket 06:首标任务经真实重切写路径产出复位状态;档案分离不变量直接钉在
// 端点产物上(退役期曾用 legacy 状态模拟)。
r = f.request(http.MethodPost, path+"/slice-reset", f.annotator, map[string]any{"version": item.Version, "resetToUnifiedRange": false})
if r.Code != http.StatusOK {
t.Fatalf("first-pass reset: %d %s", r.Code, r.Body.String())
}
item, workspace := readSliceRestoration(t, f)
if len(workspace.SliceSegments) != 3 || !workspace.SliceSegments[1].IsDiscarded() || len(workspace.Segments) != 0 {
t.Fatal("reset did not retain only outer partition")
}
if len(workspace.SliceSegments[1].DiscardedAnnotations) != 0 {
t.Fatal("reset leaves action archive live")
}
if workspace.SliceSegments[1].DiscardReason != prior.SliceSegments[1].DiscardReason {
t.Fatal("reset lost discard reason")
}
body.combinedAnnotationDraftInput = workspace
body.Version = item.Version
body.Disposition = "keep"
r = f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatalf("restore after reset: %d %s", r.Code, r.Body.String())
}
item, workspace = readSliceRestoration(t, f)
if len(workspace.Segments) != 1 {
t.Fatal("restore after reset must create one pending interval")
}
pending := workspace.Segments[0]
if pending.Start != 3 || pending.End != 7 || pending.Status != "pending" || pending.Description != "" || pending.IsInvalid {
t.Fatalf("reset revived archived judgment instead of a pending interval: %+v", pending)
}
history, _ := item.Subject.Payload["sliceDispositionHistory"].([]any)
if len(history) < 2 {
t.Fatal("reset deleted audit history")
}
// 送检历史后同端点 409,且不再追加 reset 历史。
reworkTask := f.task
reworkTask.Status = domain.AnnotationTaskStatusRework
if err := f.store.UpsertAnnotationTask(f.ctx, reworkTask); err != nil {
t.Fatal(err)
}
resetHistoryBefore, _ := normalizeStructuredValue(item.Subject.Payload["sliceResetHistory"]).([]any)
r = f.request(http.MethodPost, path+"/slice-reset", f.annotator, map[string]any{"version": item.Version, "resetToUnifiedRange": false})
if r.Code != http.StatusConflict || !strings.Contains(r.Body.String(), "slice_reset_disabled") {
t.Fatalf("reset must refuse with guidance: %d %s", r.Code, r.Body.String())
}
item, _ = readSliceRestoration(t, f)
resetHistoryAfter, _ := normalizeStructuredValue(item.Subject.Payload["sliceResetHistory"]).([]any)
if len(resetHistoryAfter) != len(resetHistoryBefore) {
t.Fatalf("refused reset appended history: %#v", resetHistoryAfter)
}
}
func TestSliceCancelMergeClearsJudgmentsAndPersistedUndoRestoresEvidence(t *testing.T) {
f := sliceRestorationFixture(t)
body := dispositionFixturePayload(t, f)
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, before := readSliceRestoration(t, f)
merged := combinedAnnotationDraftInput{Version: item.Version, SliceSegments: []domain.SliceSegment{before.SliceSegments[0], {ID: "c", Start: 3, End: 10, DeliveryDisposition: "keep", SourceIDs: []string{"b", "c"}}}, Segments: []domain.AnnotationSegment{}}
for _, snapshot := range []combinedAnnotationDraftInput{merged, before, merged, before} {
item, _ = readSliceRestoration(t, f)
snapshot.Version = item.Version
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, snapshot)
if r.Code != 200 {
t.Fatalf("save merge/undo: %d %s", r.Code, r.Body.String())
}
_, saved := readSliceRestoration(t, f)
if len(snapshot.SliceSegments) == 2 {
if saved.SliceSegments[1].IsDiscarded() || saved.SliceSegments[1].Name != "" || saved.SliceSegments[1].DiscardReason != "" || len(saved.SliceSegments[1].DiscardedAnnotations) != 0 {
t.Fatal("merge kept prior judgment")
}
} else if !saved.SliceSegments[1].IsDiscarded() || saved.SliceSegments[1].DiscardedByUserID != f.annotator.ID || len(saved.SliceSegments[1].DiscardedAnnotations) != 1 {
t.Fatal("persisted undo lost trusted discarded evidence")
}
}
}
func TestSliceResetAllSplitsFirstPassFromSubmissionHistory(t *testing.T) {
// Ticket 06:首标「全部重置」塌缩成全时长一片并留痕;送检历史后同端点 409 零改写。
f, _ := annotationProcessorFixture(t)
body := dispositionFixturePayload(t, f)
body.SliceSegments = []domain.SliceSegment{{ID: "a", Name: "测试切片", Start: 0, End: 2}, {ID: "b", Start: 2, End: 4}}
body.Segments = []domain.AnnotationSegment{{ID: "old", Start: 2, End: 4, Description: "cleared action"}}
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, _ := readSliceRestoration(t, f)
item.Subject.Payload["sliceWorkflow"] = map[string]any{"phase": "annotate", "status": "completed", "revision": 2}
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
t.Fatal(err)
}
r = f.request(http.MethodPost, path+"/slice-reset", f.annotator, map[string]any{"version": item.Version, "resetToUnifiedRange": true})
if r.Code != http.StatusOK {
t.Fatalf("first-pass reset all: %d %s", r.Code, r.Body.String())
}
saved, workspace := readSliceRestoration(t, f)
if len(workspace.SliceSegments) != 1 || workspace.SliceSegments[0].Start != 0 || workspace.SliceSegments[0].End != 4 || workspace.SliceSegments[0].Name != "" || workspace.SliceSegments[0].IsDiscarded() || len(workspace.Segments) != 0 {
t.Fatalf("reset did not restore full range: %+v", workspace.SliceSegments)
}
workflow := mapValue(saved.Subject.Payload["sliceWorkflow"])
if intValue(workflow["resetFromVersion"]) != item.Version || workflow["resetToUnifiedRange"] != true {
t.Fatal("reset outcome lacks reconciliation identity")
}
history, _ := saved.Subject.Payload["sliceResetHistory"].([]any)
if len(history) != 1 {
t.Fatal("reset dropped historical workspace evidence")
}
// A stale retry is a plain CAS conflict, not a silent success.
r = f.request(http.MethodPost, path+"/slice-reset", f.annotator, map[string]any{"version": item.Version, "resetToUnifiedRange": true})
if r.Code != http.StatusConflict || !strings.Contains(r.Body.String(), "version_conflict") {
t.Fatalf("stale reset accepted silently: %d %s", r.Code, r.Body.String())
}
// Submission history flips the same endpoint to the in-place guidance 409.
reworkTask := f.task
reworkTask.Status = domain.AnnotationTaskStatusRework
if err := f.store.UpsertAnnotationTask(f.ctx, reworkTask); err != nil {
t.Fatal(err)
}
r = f.request(http.MethodPost, path+"/slice-reset", f.annotator, map[string]any{"version": saved.Version, "resetToUnifiedRange": true})
if r.Code != http.StatusConflict || !strings.Contains(r.Body.String(), "slice_reset_disabled") {
t.Fatalf("reset all must refuse with guidance: %d %s", r.Code, r.Body.String())
}
after, workspaceAfter := readSliceRestoration(t, f)
if after.Version != saved.Version || len(workspaceAfter.SliceSegments) != 1 || len(workspaceAfter.Segments) != 0 {
t.Fatalf("refused reset changed the live workspace: %+v", workspaceAfter.SliceSegments)
}
if resetHistory, _ := after.Subject.Payload["sliceResetHistory"].([]any); len(resetHistory) != 1 {
t.Fatalf("refused reset appended reset history: %#v", resetHistory)
}
}
func TestSliceCancelMergeRejectsInventedLineageAndForeignUndoEvidence(t *testing.T) {
for _, scenario := range []string{"missing-source", "wrong-range", "invalid-disposition", "changed-reason", "foreign-restoration", "post-reset-restoration"} {
t.Run(scenario, func(t *testing.T) {
f := sliceRestorationFixture(t)
body := dispositionFixturePayload(t, f)
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, before := readSliceRestoration(t, f)
merged := combinedAnnotationDraftInput{Version: item.Version, SliceSegments: []domain.SliceSegment{before.SliceSegments[0], {ID: "c", Start: 3, End: 10, SourceIDs: []string{"b", "c"}}}, Segments: []domain.AnnotationSegment{}}
switch scenario {
case "missing-source":
merged.SliceSegments[1].SourceIDs = []string{"foreign", "c"}
case "wrong-range":
merged.SliceSegments[1].Start = 4
merged.SliceSegments[0].End = 4
case "invalid-disposition":
merged.SliceSegments[1].DeliveryDisposition = "invented"
case "changed-reason", "post-reset-restoration":
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, merged)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
if scenario == "post-reset-restoration" {
item = applyLegacySliceResetState(t, f)
} else {
item, _ = readSliceRestoration(t, f)
before.SliceSegments[1].DiscardReason = "forged reason"
}
merged = before
merged.Version = item.Version
case "foreign-restoration":
// No saved merge exists for this task. Source IDs alone cannot create a
// new discarded slice or impersonate an old discarded sibling.
merged = before
merged.SliceSegments[1].ID = "foreign"
merged.Version = item.Version
}
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, merged)
if r.Code != 400 {
t.Fatalf("unsafe %s: %d %s", scenario, r.Code, r.Body.String())
}
})
}
}
func TestSliceCancelSeveralLocalMergesCanUndoOneAtATimeAfterSave(t *testing.T) {
f := sliceRestorationFixture(t)
body := dispositionFixturePayload(t, f)
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, original := readSliceRestoration(t, f)
merged := combinedAnnotationDraftInput{Version: item.Version, SliceSegments: []domain.SliceSegment{{ID: "a", Start: 0, End: 10, SourceIDs: []string{"a", "c", "b"}}}}
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, merged)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, _ = readSliceRestoration(t, f)
intermediate := combinedAnnotationDraftInput{Version: item.Version, SliceSegments: []domain.SliceSegment{original.SliceSegments[0], {ID: "c", Start: 3, End: 10, SourceIDs: []string{"b", "c"}}}}
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, intermediate)
if r.Code != 200 {
t.Fatalf("undo one local merge: %d %s", r.Code, r.Body.String())
}
item, _ = readSliceRestoration(t, f)
original.Version = item.Version
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, original)
if r.Code != 200 {
t.Fatalf("undo second local merge: %d %s", r.Code, r.Body.String())
}
_, saved := readSliceRestoration(t, f)
if !saved.SliceSegments[1].IsDiscarded() || len(saved.SliceSegments[1].DiscardedAnnotations) != 1 {
t.Fatal("second undo lost archived evidence")
}
}
func TestSliceCancelCanSaveANewDictionaryNameBeforeSubmission(t *testing.T) {
f := sliceRestorationFixture(t)
seedSliceDictionary(t, f, "重新命名")
body := dispositionFixturePayload(t, f)
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID
r := f.request(http.MethodPost, path+"/slice-dispositions", f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, before := readSliceRestoration(t, f)
merged := combinedAnnotationDraftInput{Version: item.Version, SliceSegments: []domain.SliceSegment{before.SliceSegments[0], {ID: "c", Name: "重新命名", Start: 3, End: 10, SourceIDs: []string{"b", "c"}}}, Segments: []domain.AnnotationSegment{}}
r = f.request(http.MethodPost, path+"/slice-edit-restorations", f.annotator, merged)
if r.Code != 200 {
t.Fatalf("save redefined merge: %d %s", r.Code, r.Body.String())
}
_, saved := readSliceRestoration(t, f)
if len(saved.SliceSegments) != 2 || saved.SliceSegments[1].Name != "重新命名" || saved.SliceSegments[1].IsDiscarded() || saved.SliceSegments[1].DiscardReason != "" {
t.Fatalf("new merge name lost or stale decision retained: %+v", saved.SliceSegments)
}
}
func TestNewTaskWithoutWorkflowPhaseCanPersistExplicitSliceMerge(t *testing.T) {
f := newCombinedDraftFixture(t)
body := dispositionFixturePayload(t, f)
path := "/api/plugins/annotation-qa/tasks/" + f.task.ID + "/slice-dispositions"
r := f.request(http.MethodPost, path, f.annotator, body)
if r.Code != 200 {
t.Fatal(r.Body.String())
}
item, workspace := readSliceRestoration(t, f)
body.combinedAnnotationDraftInput = workspace
body.Version = item.Version
body.SliceSegments = []domain.SliceSegment{workspace.SliceSegments[0], {ID: "c", Start: 3, End: 10, SourceIDs: []string{"b", "c"}}}
body.SliceID = "a"
body.Disposition = "keep"
r = f.request(http.MethodPost, path, f.annotator, body)
if r.Code != 200 {
t.Fatalf("new task merge: %d %s", r.Code, r.Body.String())
}
item, _ = readSliceRestoration(t, f)
workspace.Version = item.Version
r = f.request(http.MethodPost, "/api/plugins/annotation-qa/tasks/"+f.task.ID+"/slice-edit-restorations", f.annotator, workspace)
if r.Code != 200 {
t.Fatalf("new task persisted undo: %d %s", r.Code, r.Body.String())
}
}