droboticflow/internal/store/workflow_deletion_test.go

301 lines
14 KiB
Go

package store
import (
"context"
"testing"
"droboticflow/internal/domain"
)
func TestMemoryStoreDeleteWorkflowCascadesDerivedHumanDataButRetainsProjectMembership(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{OrganizationID: "org-a", Name: "project-a"})
if err != nil {
t.Fatal(err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{OrganizationID: "org-a", ProjectID: project.ID, Name: "workflow-a"})
if err != nil {
t.Fatal(err)
}
membership := domain.ProjectAnnotationMembershipRecord{ID: "membership-a", OrganizationID: "org-a", ProjectID: project.ID, UserID: "annotator-a", WorkgroupID: "workgroup-a", AssignmentRole: domain.AnnotationRoleAnnotator}
if err := dataStore.UpsertProjectAnnotationMembership(ctx, membership); err != nil {
t.Fatal(err)
}
run := domain.RunRecord{ID: "run-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, Status: domain.RunStatusCompleted}
if err := dataStore.UpsertRun(ctx, run); err != nil {
t.Fatal(err)
}
capture := domain.CaptureRecord{ID: "capture-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, Prefix: "incoming/source-a"}
if err := dataStore.UpsertCaptureRecord(ctx, capture); err != nil {
t.Fatal(err)
}
task := domain.AnnotationTaskRecord{ID: "task-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID}
if err := dataStore.UpsertAnnotationTask(ctx, task); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertAnnotationRevision(ctx, domain.AnnotationRevisionRecord{ID: "revision-a", OrganizationID: "org-a", TaskID: task.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertSliceRevision(ctx, domain.SliceRevisionRecord{ID: "slice-a", OrganizationID: "org-a", TaskID: task.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertAnnotationReview(ctx, domain.AnnotationReviewRecord{ID: "review-a", OrganizationID: "org-a", TaskID: task.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertAnnotationWorklogEvent(ctx, domain.AnnotationWorklogEventRecord{ID: "worklog-a", OrganizationID: "org-a", ProjectID: project.ID, TaskID: task.ID}); err != nil {
t.Fatal(err)
}
batch := domain.HumanBatchRecord{ID: "batch-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID}
if err := dataStore.UpsertHumanBatch(ctx, batch); err != nil {
t.Fatal(err)
}
item := domain.HumanItemRecord{ID: "item-a", OrganizationID: "org-a", BatchID: batch.ID, ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID, CurrentStageID: "quality_review"}
if err := dataStore.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertHumanStageAttempt(ctx, domain.HumanStageAttemptRecord{ID: "attempt-a", OrganizationID: "org-a", ItemID: item.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.AppendHumanEvent(ctx, domain.HumanEventRecord{ID: "event-a", OrganizationID: "org-a", BatchID: batch.ID, ItemID: item.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertHumanReject(ctx, domain.HumanRejectRecord{ID: "reject-a", OrganizationID: "org-a", BatchID: batch.ID, ItemID: item.ID, ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertReleasePartition(ctx, domain.ReleasePartitionRecord{ID: "partition-a", OrganizationID: "org-a", BatchID: batch.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertDeliveryPackage(ctx, domain.DeliveryPackageRecord{ID: "package-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, ParentRunID: run.ID}); err != nil {
t.Fatal(err)
}
if err := dataStore.UpsertProjectWorkflowInstance(ctx, domain.ProjectWorkflowInstanceRecord{ID: "instance-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID}); err != nil {
t.Fatal(err)
}
deleted, err := dataStore.DeleteWorkflow(ctx, workflow.ID)
if err != nil || !deleted {
t.Fatalf("delete workflow: deleted=%v err=%v", deleted, err)
}
if stored, _ := dataStore.GetWorkflow(ctx, workflow.ID); stored != nil {
t.Fatalf("workflow still exists: %#v", stored)
}
if stored, _ := dataStore.GetRun(ctx, run.ID); stored != nil {
t.Fatalf("run still exists: %#v", stored)
}
if stored, _ := dataStore.GetCaptureRecord(ctx, capture.ID); stored != nil {
t.Fatalf("capture registry still exists: %#v", stored)
}
if stored, _ := dataStore.GetAnnotationTask(ctx, task.ID); stored != nil {
t.Fatalf("legacy annotation task still exists: %#v", stored)
}
if stored, _ := dataStore.GetHumanItem(ctx, item.ID); stored != nil {
t.Fatalf("human item still exists: %#v", stored)
}
if attempts, _ := dataStore.ListHumanStageAttempts(ctx, "org-a", item.ID); len(attempts) != 0 {
t.Fatalf("human attempts still exist: %#v", attempts)
}
if events, _ := dataStore.ListHumanEvents(ctx, "org-a", item.ID); len(events) != 0 {
t.Fatalf("human events still exist: %#v", events)
}
if packages, _ := dataStore.ListDeliveryPackages(ctx, "org-a", domain.DeliveryPackageQuery{WorkflowID: workflow.ID}); len(packages) != 0 {
t.Fatalf("delivery packages still exist: %#v", packages)
}
memberships, err := dataStore.ListProjectAnnotationMemberships(ctx, "org-a", project.ID)
if err != nil || len(memberships) != 1 || memberships[0].ID != membership.ID {
t.Fatalf("project membership should be retained: %#v err=%v", memberships, err)
}
if stored, _ := dataStore.GetProject(ctx, project.ID); stored == nil {
t.Fatal("project should be retained")
}
}
func TestMemoryStoreDeleteProjectAnnotationMembershipOnlyRemovesSelectedRole(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
for _, membership := range []domain.ProjectAnnotationMembershipRecord{
{ID: "annotator", OrganizationID: "org-a", ProjectID: "project-a", UserID: "user-a", WorkgroupID: "group-a", AssignmentRole: domain.AnnotationRoleAnnotator},
{ID: "reviewer", OrganizationID: "org-a", ProjectID: "project-a", UserID: "user-a", WorkgroupID: "group-a", AssignmentRole: domain.AnnotationRoleQualityReviewer},
} {
if err := dataStore.UpsertProjectAnnotationMembership(ctx, membership); err != nil {
t.Fatal(err)
}
}
deleted, err := dataStore.DeleteProjectAnnotationMembership(ctx, "annotator")
if err != nil || !deleted {
t.Fatalf("delete membership: deleted=%v err=%v", deleted, err)
}
items, err := dataStore.ListProjectAnnotationMemberships(ctx, "org-a", "project-a")
if err != nil || len(items) != 1 || items[0].ID != "reviewer" {
t.Fatalf("unexpected remaining memberships: %#v err=%v", items, err)
}
}
func TestMemoryStoreArchivedWorkflowIsNeverReturnedToWorker(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
workflow := domain.WorkflowRecord{
ID: "workflow-archived", OrganizationID: "org-a", ProjectID: "project-a",
Type: domain.WorkflowTypeStreaming, ArchivedAt: "2026-08-28T00:00:00Z",
CaptureAutomation: &domain.CaptureAutomationConfig{Enabled: true},
}
if err := dataStore.UpsertWorkflow(ctx, workflow); err != nil {
t.Fatal(err)
}
items, err := dataStore.ListWorkerWorkflows(ctx, []string{workflow.ID}, 10)
if err != nil {
t.Fatal(err)
}
if len(items) != 0 {
t.Fatalf("archived workflow leaked to worker: %#v", items)
}
}
func TestMemoryStoreDeleteProjectCascadesAllResources(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{OrganizationID: "org-a", Name: "project-a"})
if err != nil {
t.Fatal(err)
}
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{OrganizationID: "org-a", ProjectID: project.ID, Name: "workflow-a"})
if err != nil {
t.Fatal(err)
}
membership := domain.ProjectAnnotationMembershipRecord{ID: "membership-a", OrganizationID: "org-a", ProjectID: project.ID, UserID: "annotator-a", WorkgroupID: "workgroup-a", AssignmentRole: domain.AnnotationRoleAnnotator}
if err := dataStore.UpsertProjectAnnotationMembership(ctx, membership); err != nil {
t.Fatal(err)
}
tpl := domain.AnnotationTemplateRecord{ID: "tpl-a", OrganizationID: "org-a", ProjectID: project.ID, Name: "tpl-a", Version: 1}
if err := dataStore.UpsertAnnotationTemplate(ctx, tpl); err != nil {
t.Fatal(err)
}
run := domain.RunRecord{ID: "run-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, Status: domain.RunStatusCompleted}
if err := dataStore.UpsertRun(ctx, run); err != nil {
t.Fatal(err)
}
task := domain.AnnotationTaskRecord{ID: "task-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID}
if err := dataStore.UpsertAnnotationTask(ctx, task); err != nil {
t.Fatal(err)
}
batch := domain.HumanBatchRecord{ID: "batch-a", OrganizationID: "org-a", ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID}
if err := dataStore.UpsertHumanBatch(ctx, batch); err != nil {
t.Fatal(err)
}
item := domain.HumanItemRecord{ID: "item-a", OrganizationID: "org-a", BatchID: batch.ID, ProjectID: project.ID, WorkflowID: workflow.ID, RunID: run.ID, CurrentStageID: "quality_review"}
if err := dataStore.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
deleted, err := dataStore.DeleteProject(ctx, project.ID)
if err != nil || !deleted {
t.Fatalf("delete project: deleted=%v err=%v", deleted, err)
}
if stored, _ := dataStore.GetProject(ctx, project.ID); stored != nil {
t.Fatalf("project still exists: %#v", stored)
}
if stored, _ := dataStore.GetWorkflow(ctx, workflow.ID); stored != nil {
t.Fatalf("workflow still exists: %#v", stored)
}
if stored, _ := dataStore.GetRun(ctx, run.ID); stored != nil {
t.Fatalf("run still exists: %#v", stored)
}
if stored, _ := dataStore.GetAnnotationTask(ctx, task.ID); stored != nil {
t.Fatalf("annotation task still exists: %#v", stored)
}
if stored, _ := dataStore.GetHumanItem(ctx, item.ID); stored != nil {
t.Fatalf("human item still exists: %#v", stored)
}
if stored, _ := dataStore.GetHumanBatch(ctx, batch.ID); stored != nil {
t.Fatalf("human batch still exists: %#v", stored)
}
if stored, _ := dataStore.GetAnnotationTemplate(ctx, tpl.ID); stored != nil {
t.Fatalf("annotation template still exists: %#v", stored)
}
if memberships, _ := dataStore.ListProjectAnnotationMemberships(ctx, "org-a", project.ID); len(memberships) != 0 {
t.Fatalf("memberships still exist: %#v", memberships)
}
}
func TestMemoryStoreDeleteTemplateRetainsReferencedReleases(t *testing.T) {
ctx := context.Background()
s := NewMemoryStore()
if err := s.UpsertTemplate(ctx, domain.TemplateRecord{ID: "template", OrganizationID: "org-a"}); err != nil {
t.Fatal(err)
}
for _, id := range []string{"instance-release", "run-release", "unused-release"} {
if err := s.UpsertWorkflowRelease(ctx, domain.WorkflowReleaseRecord{ID: id, TemplateID: "template", OrganizationID: "org-a"}); err != nil {
t.Fatal(err)
}
}
if err := s.UpsertProjectWorkflowInstance(ctx, domain.ProjectWorkflowInstanceRecord{ID: "instance", ReleaseID: "instance-release", SourceTemplateID: "template", OrganizationID: "org-a"}); err != nil {
t.Fatal(err)
}
if err := s.UpsertRun(ctx, domain.RunRecord{ID: "run", ReleaseID: "run-release", OrganizationID: "org-a"}); err != nil {
t.Fatal(err)
}
if ok, err := s.DeleteTemplate(ctx, "template"); err != nil || !ok {
t.Fatalf("delete: %v %v", ok, err)
}
for _, id := range []string{"instance-release", "run-release"} {
if r, err := s.GetWorkflowRelease(ctx, id); err != nil || r == nil {
t.Fatalf("referenced release lost: %s %v", id, err)
}
}
if r, _ := s.GetWorkflowRelease(ctx, "unused-release"); r != nil {
t.Fatal("unused release retained")
}
if item, _ := s.GetTemplate(ctx, "template"); item != nil {
t.Fatal("template entry retained")
}
if ok, err := s.DeleteTemplate(ctx, "template"); err != nil || ok {
t.Fatalf("repeat delete: %v %v", ok, err)
}
}
func TestMemoryStoreDeleteTemplateCascadesWorkflowReleases(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
template := domain.TemplateRecord{ID: "tpl-target", OrganizationID: "org-a", Name: "template to delete"}
if err := dataStore.UpsertTemplate(ctx, template); err != nil {
t.Fatal(err)
}
release := domain.WorkflowReleaseRecord{ID: "release-target", OrganizationID: "org-a", TemplateID: template.ID, Version: 1}
if err := dataStore.UpsertWorkflowRelease(ctx, release); err != nil {
t.Fatal(err)
}
deleted, err := dataStore.DeleteTemplate(ctx, template.ID)
if err != nil || !deleted {
t.Fatalf("delete template: deleted=%v err=%v", deleted, err)
}
if stored, _ := dataStore.GetTemplate(ctx, template.ID); stored != nil {
t.Fatalf("template should be deleted: %#v", stored)
}
releases, err := dataStore.ListWorkflowReleases(ctx, "org-a", domain.WorkflowReleaseQuery{TemplateID: template.ID})
if err != nil || len(releases) != 0 {
t.Fatalf("workflow releases should be cascaded: %#v err=%v", releases, err)
}
}
func TestMemoryStoreDeleteOrganizationCascadesAnnotationLabels(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
org := domain.OrganizationRecord{ID: "org-custom", Name: "org-custom"}
if err := dataStore.UpsertOrganization(ctx, org); err != nil {
t.Fatal(err)
}
label := domain.AnnotationLabelRecord{ID: "label-custom", OrganizationID: org.ID, Code: "cat"}
if err := dataStore.UpsertAnnotationLabel(ctx, label); err != nil {
t.Fatal(err)
}
deleted, err := dataStore.DeleteOrganizationCascade(ctx, org.ID)
if err != nil || !deleted {
t.Fatalf("delete org cascade: deleted=%v err=%v", deleted, err)
}
labels, err := dataStore.ListAnnotationLabels(ctx, org.ID)
if err != nil || len(labels) != 0 {
t.Fatalf("labels should be cascaded: %#v err=%v", labels, err)
}
}