droboticflow/internal/store/annotation_availability_test.go

133 lines
5.9 KiB
Go

package store
import (
"context"
"droboticflow/internal/domain"
"fmt"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
"os"
"reflect"
"testing"
"time"
)
func TestSourceAdvisoryDoesNotGateOnFullAudit(t *testing.T) {
t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory")
task := domain.AnnotationTaskRecord{ID: "task", OrganizationID: "org", ProjectID: "project", RunID: "run"}
item := domain.HumanItemRecord{LegacyTaskID: task.ID, OrganizationID: task.OrganizationID, ProjectID: task.ProjectID, RunID: task.RunID}
for _, state := range []string{"", "queued", "running", "failed", "completed"} {
var job *domain.AnnotationIndexJob
if state != "" {
job = &domain.AnnotationIndexJob{ID: task.ID, OrganizationID: task.OrganizationID, ProjectID: task.ProjectID, RunID: task.RunID, Status: state, Error: "source video duration does not match its fixed frame cadence"}
}
if !AnnotationItemSourceJobsReady(task, item, job, nil) || AnnotationSourceAdmissionStatus(task, item, job, nil) != "" {
t.Fatalf("full audit %q still gates work", state)
}
}
}
func TestSourceAdvisoryMongoEquivalenceAndBuffer(t *testing.T) {
if os.Getenv("SOURCE_ADMISSION_LOCAL_MONGO") != "1" {
t.Skip("isolated Mongo opt-in")
}
t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory")
ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second)
defer cancel()
c, e := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://127.0.0.1:27018/?directConnection=true").SetServerSelectionTimeout(3*time.Second))
if e != nil {
t.Fatal(e)
}
defer c.Disconnect(context.Background())
db := c.Database(fmt.Sprintf("source_advisory_%d", time.Now().UnixNano()))
defer db.Drop(context.Background())
m := NewMongoStore(db)
memory := NewMemoryStore()
org, user, project := "advisory-org", "owner", "project"
batch := domain.HumanBatchRecord{ID: "batch", OrganizationID: org, ProjectID: project, WorkflowID: "workflow", PluginID: "annotation-qa", ProcessingProfile: domain.ProcessingProfileRawHuman, Stages: domain.DefaultFanyuV58HumanStages()}
must := func(e error) {
t.Helper()
if e != nil {
t.Fatal(e)
}
}
must(m.UpsertHumanBatch(ctx, batch))
must(memory.UpsertHumanBatch(ctx, batch))
items := []domain.HumanItemRecord{}
for n, state := range []string{"", "queued", "running", "failed", "completed", "unusable"} {
id := fmt.Sprintf("item-%d", n)
task := domain.AnnotationTaskRecord{ID: "task-" + id, OrganizationID: org, ProjectID: project, RunID: id}
must(m.UpsertAnnotationTask(ctx, task))
item := domain.HumanItemRecord{ID: id, OrganizationID: org, ProjectID: project, WorkflowID: batch.WorkflowID, RunID: id, PluginID: "annotation-qa", BatchID: batch.ID, LegacyTaskID: task.ID, CurrentStageID: "annotation_combined", Status: domain.HumanItemClaimed, AssignedUserID: user, Version: 1, Subject: domain.HumanSubjectRef{Payload: map[string]any{"annotationDraft": map[string]any{"description": "keep existing annotation"}}}}
if state == "unusable" {
item.ProcessingJob = &domain.AnnotationProcessingJob{Status: "failed", Error: AnnotationSourceUnavailablePrefix + "video frame count mismatch"}
} else if state != "" {
_, e = db.Collection("annotationIndexJobs").InsertOne(ctx, domain.AnnotationIndexJob{ID: task.ID, OrganizationID: org, ProjectID: project, RunID: id, Status: state, Error: "source video duration does not match its fixed frame cadence"})
must(e)
}
must(m.UpsertHumanItem(ctx, item))
must(memory.UpsertHumanItem(ctx, item))
saved, err := m.GetHumanItem(ctx, item.ID)
must(err)
items = append(items, *saved)
}
cur, e := db.Collection("humanItems").Aggregate(ctx, annotationSourceAdmissionPipeline())
must(e)
rows, e := decodeMany[domain.HumanItemRecord](ctx, cur)
must(e)
if len(rows) != 5 {
t.Fatalf("advisory retained %d expected 5", len(rows))
}
must(m.EnrichAnnotationSourceStatuses(ctx, items))
for n, item := range items {
want := ""
if n == 5 {
want = "failed"
}
if item.SourceValidationStatus != want {
t.Fatalf("wrong status %q", item.SourceValidationStatus)
}
}
_, e = db.Collection("annotationWorkBuffers").InsertOne(ctx, bson.M{"_id": bufferKey(org, user, project), "capacity": 8, "version": 0, "slots": bson.M{"old-request": "item-5"}})
must(e)
for _, compact := range []bool{false, true} {
buffer, e := m.annotationBuffer(ctx, org, user, project, 0, nil, compact)
must(e)
if buffer.Occupied != 5 || len(buffer.Items) != 6 {
t.Fatalf("buffer lost failed task or counted isolated slot: occupied=%d items=%d", buffer.Occupied, len(buffer.Items))
}
if _, ok := buffer.Slots["old-request"]; ok {
t.Fatal("isolated task retained slot")
}
}
buffer, e := memory.AnnotationWorkBuffer(ctx, org, user, project, 8)
must(e)
if buffer.Occupied != 5 || len(buffer.Items) != 6 {
t.Fatal("memory buffer differs")
}
for _, before := range items {
after, e := m.GetHumanItem(ctx, before.ID)
must(e)
before.SourceValidationStatus = ""
if !reflect.DeepEqual(before, *after) {
t.Fatal("buffer changed retained annotations or ownership")
}
}
}
func TestSourceAdvisoryTaskScopeCannotBeBypassed(t *testing.T) {
t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "advisory")
task := domain.AnnotationTaskRecord{ID: "task", OrganizationID: "org", ProjectID: "project", RunID: "run"}
item := domain.HumanItemRecord{LegacyTaskID: task.ID, OrganizationID: task.OrganizationID, ProjectID: task.ProjectID, RunID: task.RunID}
for _, bad := range []domain.AnnotationTaskRecord{{}, {ID: task.ID, OrganizationID: task.OrganizationID, ProjectID: "foreign", RunID: task.RunID}} {
if AnnotationItemSourceJobsReady(bad, item, nil, nil) || AnnotationSourceAdmissionStatus(bad, item, nil, nil) == "" {
t.Fatal("missing/foreign task reference was admitted")
}
}
t.Setenv("ANNOTATION_SOURCE_VALIDATION_MODE", "disabled")
if AnnotationItemSourceJobsReady(task, item, nil, nil) || !AnnotationSourceValidationRequired(task) {
t.Fatal("unknown mode relaxed strict admission")
}
}