forked from longtao.wu/droboticflow
133 lines
5.9 KiB
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")
|
|
}
|
|
}
|