219 lines
9.4 KiB
Go
219 lines
9.4 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
)
|
|
|
|
func TestHumanDisplayResolverBuildsBusinessHierarchyFromLegacyArtifact(t *testing.T) {
|
|
ctx := context.Background()
|
|
dataStore := store.NewMemoryStore()
|
|
_ = dataStore.UpsertProject(ctx, domain.ProjectRecord{ID: "project-a", OrganizationID: "org-a", Name: "泛宇项目"})
|
|
_ = dataStore.UpsertWorkflow(ctx, domain.WorkflowRecord{ID: "workflow-a", OrganizationID: "org-a", ProjectID: "project-a", Name: "持续处理工作流"})
|
|
_ = dataStore.UpsertRun(ctx, domain.RunRecord{ID: "run-a", OrganizationID: "org-a", ProjectID: "project-a", ProjectName: "泛宇项目", WorkflowID: "workflow-a", WorkflowName: "持续处理工作流"})
|
|
_ = dataStore.UpsertAnnotationTask(ctx, domain.AnnotationTaskRecord{
|
|
ID: "task-a", OrganizationID: "org-a", ProjectID: "project-a", WorkflowID: "workflow-a", RunID: "run-a",
|
|
ArtifactID: "run-a-blurred_Orbbec_Ego_CAPTURE_0001_camera_left_part0001.mp4",
|
|
})
|
|
item := domain.HumanItemRecord{ID: "item-a", OrganizationID: "org-a", ProjectID: "project-a", WorkflowID: "workflow-a", RunID: "run-a", LegacyTaskID: "task-a"}
|
|
resolver := newHumanDisplayResolver(&server{store: dataStore})
|
|
if err := resolver.enrichItem(ctx, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if item.Display == nil || item.Display.ProjectName != "泛宇项目" || item.Display.WorkflowName != "持续处理工作流" || len(item.Display.CaptureDirectories) != 1 || item.Display.CaptureDirectories[0] != "Orbbec_Ego_CAPTURE_0001" {
|
|
t.Fatalf("display context = %#v", item.Display)
|
|
}
|
|
}
|
|
|
|
func TestHumanDisplayResolverPrefersCaptureRecordDirectoryOverFilePrefix(t *testing.T) {
|
|
ctx := context.Background()
|
|
dataStore := store.NewMemoryStore()
|
|
_ = dataStore.UpsertProject(ctx, domain.ProjectRecord{ID: "project-a", OrganizationID: "org-a", Name: "泛宇项目"})
|
|
_ = dataStore.UpsertWorkflow(ctx, domain.WorkflowRecord{ID: "workflow-a", OrganizationID: "org-a", ProjectID: "project-a", Name: "持续处理工作流"})
|
|
_ = dataStore.UpsertCaptureRecord(ctx, domain.CaptureRecord{
|
|
ID: "capture-record-a", OrganizationID: "org-a", ProjectID: "project-a", WorkflowID: "workflow-a",
|
|
CaptureID: "客户自定义目录-42", Prefix: "test/客户自定义目录-42",
|
|
})
|
|
_ = dataStore.UpsertRun(ctx, domain.RunRecord{
|
|
ID: "run-a", OrganizationID: "org-a", ProjectID: "project-a", ProjectName: "泛宇项目",
|
|
WorkflowID: "workflow-a", WorkflowName: "持续处理工作流", TaskID: "capture-record-a",
|
|
})
|
|
item := domain.HumanItemRecord{
|
|
ID: "item-a", OrganizationID: "org-a", ProjectID: "project-a", WorkflowID: "workflow-a", RunID: "run-a",
|
|
Subject: domain.HumanSubjectRef{ItemKey: "Orbbec_Ego_DEVICE_20260829_camera_left_part0001.mp4"},
|
|
}
|
|
resolver := newHumanDisplayResolver(&server{store: dataStore})
|
|
if err := resolver.enrichItem(ctx, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if item.Display == nil || len(item.Display.CaptureDirectories) != 1 || item.Display.CaptureDirectories[0] != "客户自定义目录-42" {
|
|
t.Fatalf("display context = %#v", item.Display)
|
|
}
|
|
}
|
|
|
|
// Instrument the real fallback store path rather than just checking JSON size.
|
|
type displayTaskReadStore struct {
|
|
store.Store
|
|
reads int
|
|
}
|
|
|
|
func (s *displayTaskReadStore) GetAnnotationTask(ctx context.Context, id string) (*domain.AnnotationTaskRecord, error) {
|
|
s.reads++
|
|
return s.Store.GetAnnotationTask(ctx, id)
|
|
}
|
|
func TestHumanDisplayResolverReadsTaskOnlyForMissingCapture(t *testing.T) {
|
|
ctx := context.Background()
|
|
data := &displayTaskReadStore{Store: store.NewMemoryStore()}
|
|
if err := data.UpsertAnnotationTask(ctx, domain.AnnotationTaskRecord{ID: "fallback", ArtifactID: "run-a-blurred_Orbbec_Ego_CAPTURE_0001_camera_left_part0001.mp4"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
resolver := newHumanDisplayResolver(&server{store: data})
|
|
item := domain.HumanItemRecord{LegacyTaskID: "fallback", Subject: domain.HumanSubjectRef{ItemKey: "Orbbec_Ego_DEVICE_20260829_camera_left_part0001.mp4"}}
|
|
if err := resolver.enrichItem(ctx, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if data.reads != 0 || item.Display == nil || len(item.Display.CaptureDirectories) == 0 {
|
|
t.Fatalf("resolved capture fetched fallback: %d %+v", data.reads, item.Display)
|
|
}
|
|
item.Subject = domain.HumanSubjectRef{}
|
|
for i := 0; i < 2; i++ {
|
|
if err := resolver.enrichItem(ctx, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if data.reads != 1 || len(item.Display.CaptureDirectories) != 1 || item.Display.CaptureDirectories[0] != "Orbbec_Ego_CAPTURE_0001" {
|
|
t.Fatalf("legacy fallback/cache changed: %d %+v", data.reads, item.Display)
|
|
}
|
|
}
|
|
}
|
|
|
|
type displayRunReadStore struct {
|
|
store.Store
|
|
fullReads int
|
|
headerReads int
|
|
headerIDs []string
|
|
legacyHeader bool
|
|
}
|
|
|
|
func (s *displayRunReadStore) GetRun(ctx context.Context, id string) (*domain.RunRecord, error) {
|
|
s.fullReads++
|
|
return s.Store.GetRun(ctx, id)
|
|
}
|
|
func TestHumanDisplayResolvedCaptureSkipsFullRun(t *testing.T) {
|
|
ctx := context.Background()
|
|
data := &displayRunReadStore{Store: store.NewMemoryStore()}
|
|
if err := data.UpsertRun(ctx, domain.RunRecord{ID: "run", ProjectName: "historic project", WorkflowName: "historic workflow", CaptureDirectories: []string{"legacy directory"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
item := domain.HumanItemRecord{RunID: "run", Subject: domain.HumanSubjectRef{ItemKey: "Orbbec_Ego_DEVICE_20260829_camera_left_part0001.mp4"}}
|
|
resolver := newHumanDisplayResolver(&server{store: data})
|
|
if err := resolver.enrichItem(ctx, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if data.fullReads != 0 {
|
|
t.Fatalf("display loaded full run although capture already resolved: %d", data.fullReads)
|
|
}
|
|
if item.Display.ProjectName != "historic project" || item.Display.WorkflowName != "historic workflow" || len(item.Display.CaptureDirectories) != 1 || item.Display.CaptureDirectories[0] == "legacy directory" {
|
|
t.Fatalf("display precedence changed: %+v", item.Display)
|
|
}
|
|
item.Subject = domain.HumanSubjectRef{}
|
|
if err := resolver.enrichItem(ctx, &item); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(item.Display.CaptureDirectories) != 1 || item.Display.CaptureDirectories[0] != "legacy directory" {
|
|
t.Fatalf("legacy directory lost: %+v", item.Display)
|
|
}
|
|
}
|
|
|
|
func (s *displayRunReadStore) ListHumanRunDisplays(ctx context.Context, ids []string) ([]domain.HumanRunDisplay, error) {
|
|
s.headerReads++
|
|
s.headerIDs = append(s.headerIDs, ids...)
|
|
rows, err := s.Store.ListHumanRunDisplays(ctx, ids)
|
|
if s.legacyHeader {
|
|
for i := range rows {
|
|
rows[i].CaptureDirectories = nil
|
|
}
|
|
}
|
|
return rows, err
|
|
}
|
|
func TestHumanDisplayBatchesRunsAndKeepsLegacyFallback(t *testing.T) {
|
|
ctx := context.Background()
|
|
data := &displayRunReadStore{Store: store.NewMemoryStore(), legacyHeader: true}
|
|
if err := data.UpsertRun(ctx, domain.RunRecord{ID: "legacy", NodeExecutions: []domain.NodeExecutionRecord{{Artifacts: []domain.ExecutionArtifact{{Name: "blurred_Orbbec_Ego_CAPTURE_A_camera_left_part0001.mp4"}}}}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r := newHumanDisplayResolver(&server{store: data})
|
|
items := []domain.HumanItemRecord{{RunID: "legacy"}, {RunID: "legacy"}, {RunID: "missing"}, {RunID: "missing"}}
|
|
if err := r.primeRuns(ctx, items); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for i := range items {
|
|
if err := r.enrichItem(ctx, &items[i]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if data.headerReads != 1 || len(data.headerIDs) != 2 || data.fullReads != 1 {
|
|
t.Fatalf("batched/missing/legacy cache: headers=%d IDs=%v full=%d", data.headerReads, data.headerIDs, data.fullReads)
|
|
}
|
|
for _, i := range []int{0, 1} {
|
|
if len(items[i].Display.CaptureDirectories) != 1 || items[i].Display.CaptureDirectories[0] != "Orbbec_Ego_CAPTURE_A" {
|
|
t.Fatalf("lost legacy artifact: %+v", items[i].Display)
|
|
}
|
|
}
|
|
}
|
|
|
|
type displayCaptureReadStore struct {
|
|
store.Store
|
|
batches, singles int
|
|
}
|
|
|
|
func (s *displayCaptureReadStore) GetCaptureRecord(ctx context.Context, id string) (*domain.CaptureRecord, error) {
|
|
s.singles++
|
|
return s.Store.GetCaptureRecord(ctx, id)
|
|
}
|
|
func (s *displayCaptureReadStore) ListHumanCaptureDisplays(ctx context.Context, ids []string) ([]domain.HumanCaptureDisplay, error) {
|
|
s.batches++
|
|
return s.Store.ListHumanCaptureDisplays(ctx, ids)
|
|
}
|
|
func TestHumanDisplayBatchesDistinctCapturesAndCachesMissing(t *testing.T) {
|
|
ctx := context.Background()
|
|
data := &displayCaptureReadStore{Store: store.NewMemoryStore()}
|
|
items := []domain.HumanItemRecord{}
|
|
for n := 0; n < 20; n++ {
|
|
id := fmt.Sprint(n)
|
|
if err := data.UpsertRun(ctx, domain.RunRecord{ID: "run" + id, TaskID: "capture" + id}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if n < 19 {
|
|
if err := data.UpsertCaptureRecord(ctx, domain.CaptureRecord{ID: "capture" + id, CaptureID: "directory" + id}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
items = append(items, domain.HumanItemRecord{RunID: "run" + id, Subject: domain.HumanSubjectRef{ItemKey: "Orbbec_Ego_FALLBACK_camera_left_part0001.mp4"}})
|
|
}
|
|
resolver := newHumanDisplayResolver(&server{store: data})
|
|
if err := resolver.primeRuns(ctx, items); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for repeat := 0; repeat < 2; repeat++ {
|
|
for n := range items {
|
|
if err := resolver.enrichItem(ctx, &items[n]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := fmt.Sprint("directory", n)
|
|
if n == 19 {
|
|
want = "Orbbec_Ego_FALLBACK"
|
|
}
|
|
if items[n].Display == nil || len(items[n].Display.CaptureDirectories) != 1 || items[n].Display.CaptureDirectories[0] != want {
|
|
t.Fatalf("display %d: %+v", n, items[n].Display)
|
|
}
|
|
}
|
|
}
|
|
if data.batches != 1 || data.singles != 0 {
|
|
t.Fatalf("capture reads: batches=%d singles=%d; want one projected batch", data.batches, data.singles)
|
|
}
|
|
}
|