forked from longtao.wu/droboticflow
102 lines
4.0 KiB
Go
102 lines
4.0 KiB
Go
package api
|
|
|
|
import (
|
|
"droboticflow/internal/domain"
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestHumanPoolSummaryAndCountPreserveAuthorization(t *testing.T) {
|
|
f := sharedAcceptanceFixture(t)
|
|
f.item.Subject.Payload["hugeDetail"] = strings.Repeat("private draft ", 100000)
|
|
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
full := f.request("GET", "/api/human-items?pluginId=annotation-qa&pool=available", f.reviewer, nil)
|
|
summary := f.request("GET", "/api/human-item-summaries?pluginId=annotation-qa&pool=available", f.reviewer, nil)
|
|
if full.Code != 200 || summary.Code != 200 {
|
|
t.Fatalf("full=%d summary=%d %s", full.Code, summary.Code, summary.Body.String())
|
|
}
|
|
var before struct {
|
|
Items []domain.HumanItemRecord `json:"items"`
|
|
}
|
|
var after struct {
|
|
Summaries []humanPoolSummary `json:"summaries"`
|
|
}
|
|
if err := json.Unmarshal(full.Body.Bytes(), &before); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal(summary.Body.Bytes(), &after); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Compare the public metadata contract independently of the DTO converter.
|
|
var fullJSON, summaryJSON map[string]any
|
|
_ = json.Unmarshal(full.Body.Bytes(), &fullJSON)
|
|
_ = json.Unmarshal(summary.Body.Bytes(), &summaryJSON)
|
|
for index, value := range fullJSON["items"].([]any) {
|
|
expected := value.(map[string]any)
|
|
delete(expected["subject"].(map[string]any), "payload")
|
|
actual := summaryJSON["summaries"].([]any)[index].(map[string]any)
|
|
delete(actual, "kind")
|
|
delete(actual, "durationSeconds")
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Fatalf("public list metadata changed: expected=%v actual=%v", expected, actual)
|
|
}
|
|
}
|
|
if len(before.Items) != len(after.Summaries) || len(after.Summaries) == 0 {
|
|
t.Fatal("summary lost rows")
|
|
}
|
|
for i, item := range before.Items {
|
|
want := summarizeHumanPoolItem(item)
|
|
if !reflect.DeepEqual(want, after.Summaries[i]) {
|
|
t.Fatalf("summary metadata changed: %#v %#v", want, after.Summaries[i])
|
|
}
|
|
}
|
|
if len(summary.Body.Bytes()) >= 10000 || strings.Contains(summary.Body.String(), "private draft") {
|
|
t.Fatal("summary returned detail")
|
|
}
|
|
counts := f.request("GET", "/api/human-item-counts?pluginId=annotation-qa&stageIds=acceptance,prepackage_acceptance&reviewedStageIds=acceptance,prepackage_acceptance", f.reviewer, nil)
|
|
var totals struct {
|
|
Counts map[string]int `json:"counts"`
|
|
}
|
|
if counts.Code != 200 || json.Unmarshal(counts.Body.Bytes(), &totals) != nil || totals.Counts["available"] != len(before.Items) {
|
|
t.Fatalf("counts=%d %s", counts.Code, counts.Body.String())
|
|
}
|
|
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, path := range []string{"/api/human-item-summaries?pool=available&pluginId=annotation-qa", "/api/human-item-counts?pluginId=annotation-qa"} {
|
|
result := f.request("GET", path, f.reviewer, nil)
|
|
if result.Code != 200 || strings.Contains(result.Body.String(), `"canClaim":true`) {
|
|
t.Fatalf("revoked result %d %s", result.Code, result.Body.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHumanPoolCountsTraversesPagesWithoutHydratingPayloads(t *testing.T) {
|
|
f := newFanyuV5FourStageFixture(t, domain.FanyuV5StageSemanticReview, domain.HumanItemReady, "", 1)
|
|
for n := 0; n < 1005; n++ {
|
|
item := f.item
|
|
item.ID = fmt.Sprintf("count-%04d", n)
|
|
item.CreatedAt = time.Date(2026, 11, 1, 0, 0, n, 0, time.UTC).Format(time.RFC3339Nano)
|
|
item.Subject.Payload = map[string]any{"hugeDetail": strings.Repeat("x", 10000)}
|
|
if err := f.store.UpsertHumanItem(f.ctx, item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
result := f.request("GET", "/api/human-item-counts?pluginId=annotation-qa&stageIds=semantic_review", f.quality, nil)
|
|
var body struct {
|
|
Counts map[string]int `json:"counts"`
|
|
}
|
|
if result.Code != 200 || json.Unmarshal(result.Body.Bytes(), &body) != nil || body.Counts["available"] != 1006 {
|
|
t.Fatalf("count=%d %s", result.Code, result.Body.String())
|
|
}
|
|
if result.Body.Len() > 500 {
|
|
t.Fatal("count hydrated details")
|
|
}
|
|
}
|