forked from longtao.wu/droboticflow
278 lines
7.4 KiB
Go
278 lines
7.4 KiB
Go
package store_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
)
|
|
|
|
func TestMemoryStoreCRUD(t *testing.T) {
|
|
ctx := context.Background()
|
|
dataStore := store.NewMemoryStore()
|
|
|
|
storageRoot := t.TempDir()
|
|
for _, bucket := range []string{"incoming", "processed"} {
|
|
if err := os.Mkdir(filepath.Join(storageRoot, bucket), 0o755); err != nil {
|
|
t.Fatalf("create bucket %s: %v", bucket, err)
|
|
}
|
|
}
|
|
|
|
settings, err := dataStore.GetSettings(ctx)
|
|
if err != nil {
|
|
t.Fatalf("get settings: %v", err)
|
|
}
|
|
if err := dataStore.UpsertSettings(ctx, *settings); err != nil {
|
|
t.Fatalf("update settings: %v", err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(storageRoot, "incoming", "clips"), 0o755); err != nil {
|
|
t.Fatalf("create nested prefix: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(storageRoot, "incoming", "clips", "sample.mp4"), []byte("data"), 0o644); err != nil {
|
|
t.Fatalf("write sample object: %v", err)
|
|
}
|
|
|
|
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
|
|
Name: "新项目",
|
|
Description: "用于仓储测试",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create project: %v", err)
|
|
}
|
|
if project.ID == "" {
|
|
t.Fatalf("expected created project id")
|
|
}
|
|
|
|
operator, err := dataStore.CreateOperator(ctx, domain.CreateOperatorInput{
|
|
Name: "真实数据源",
|
|
Type: "builtin",
|
|
Category: "IO",
|
|
Description: "Emit a manifest artifact from source text",
|
|
Inputs: []domain.PortDefinition{},
|
|
Outputs: []domain.PortDefinition{
|
|
{ID: "out-1", Name: "manifest", Type: domain.PortTypeJSON},
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create operator: %v", err)
|
|
}
|
|
if operator.ID == "" {
|
|
t.Fatalf("expected created operator id")
|
|
}
|
|
|
|
template, err := dataStore.CreateTemplate(ctx, domain.CreateTemplateInput{
|
|
Name: "基础模板",
|
|
Description: "用于模板列表测试",
|
|
Nodes: []domain.WorkflowNode{
|
|
{
|
|
ID: "node-1",
|
|
Type: "operator",
|
|
Data: domain.WorkflowNodeData{
|
|
Label: "真实数据源",
|
|
Category: "IO",
|
|
Description: "source",
|
|
Outputs: []domain.PortDefinition{
|
|
{ID: "out-1", Name: "manifest", Type: domain.PortTypeJSON},
|
|
},
|
|
},
|
|
Position: domain.Position{X: 0, Y: 0},
|
|
},
|
|
},
|
|
Edges: []domain.WorkflowEdge{},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create template: %v", err)
|
|
}
|
|
if template.ID == "" {
|
|
t.Fatalf("expected created template id")
|
|
}
|
|
|
|
user, err := dataStore.CreateUser(ctx, domain.CreateUserInput{
|
|
Name: "测试用户",
|
|
Email: "tester@example.com",
|
|
Role: domain.UserRoleAdmin,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create user: %v", err)
|
|
}
|
|
if user.ID == "" {
|
|
t.Fatalf("expected created user id")
|
|
}
|
|
|
|
projects, err := dataStore.ListProjects(ctx)
|
|
if err != nil {
|
|
t.Fatalf("list projects: %v", err)
|
|
}
|
|
if len(projects) != 1 {
|
|
t.Fatalf("expected 1 project, got %d", len(projects))
|
|
}
|
|
|
|
operators, err := dataStore.ListOperators(ctx)
|
|
if err != nil {
|
|
t.Fatalf("list operators: %v", err)
|
|
}
|
|
if len(operators) != 1 {
|
|
t.Fatalf("expected 1 operator, got %d", len(operators))
|
|
}
|
|
|
|
templates, err := dataStore.ListTemplates(ctx)
|
|
if err != nil {
|
|
t.Fatalf("list templates: %v", err)
|
|
}
|
|
if len(templates) != 1 {
|
|
t.Fatalf("expected 1 template, got %d", len(templates))
|
|
}
|
|
|
|
users, err := dataStore.ListUsers(ctx)
|
|
if err != nil {
|
|
t.Fatalf("list users: %v", err)
|
|
}
|
|
if len(users) != 1 {
|
|
t.Fatalf("expected 1 user, got %d", len(users))
|
|
}
|
|
|
|
buckets, err := dataStore.ListStorageBuckets(ctx, storageRoot)
|
|
if err != nil {
|
|
t.Fatalf("list storage buckets: %v", err)
|
|
}
|
|
if len(buckets) != 2 {
|
|
t.Fatalf("expected 2 buckets, got %d", len(buckets))
|
|
}
|
|
|
|
objects, err := dataStore.ListStorageObjects(ctx, storageRoot, "incoming", "clips")
|
|
if err != nil {
|
|
t.Fatalf("list storage objects: %v", err)
|
|
}
|
|
if len(objects) != 1 || objects[0] != "clips/sample.mp4" {
|
|
t.Fatalf("unexpected storage objects: %#v", objects)
|
|
}
|
|
|
|
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
|
|
ProjectID: project.ID,
|
|
Name: "测试工作流",
|
|
Description: "测试 DAG",
|
|
Type: domain.WorkflowTypeBatch,
|
|
Nodes: []domain.WorkflowNode{
|
|
{
|
|
ID: "n1",
|
|
Type: "operator",
|
|
Data: domain.WorkflowNodeData{
|
|
Label: "真实数据源",
|
|
Category: "IO",
|
|
Description: "source",
|
|
Inputs: []domain.PortDefinition{},
|
|
Outputs: []domain.PortDefinition{
|
|
{ID: "out-1", Name: "manifest", Type: domain.PortTypeJSON},
|
|
},
|
|
},
|
|
Position: domain.Position{X: 0, Y: 0},
|
|
},
|
|
},
|
|
Edges: []domain.WorkflowEdge{},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create workflow: %v", err)
|
|
}
|
|
if workflow.ProjectID != project.ID {
|
|
t.Fatalf("expected workflow project %s, got %s", project.ID, workflow.ProjectID)
|
|
}
|
|
|
|
projectWorkflows, err := dataStore.ListWorkflowsByProject(ctx, project.ID)
|
|
if err != nil {
|
|
t.Fatalf("list project workflows: %v", err)
|
|
}
|
|
if len(projectWorkflows) != 1 {
|
|
t.Fatalf("expected workflow in project listing")
|
|
}
|
|
|
|
project.Description = "已更新描述"
|
|
project.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
|
|
if err := dataStore.UpsertProject(ctx, *project); err != nil {
|
|
t.Fatalf("update project: %v", err)
|
|
}
|
|
|
|
updatedProject, err := dataStore.GetProject(ctx, project.ID)
|
|
if err != nil {
|
|
t.Fatalf("get updated project: %v", err)
|
|
}
|
|
if updatedProject == nil || updatedProject.Description != "已更新描述" {
|
|
t.Fatalf("expected updated description")
|
|
}
|
|
|
|
deleted, err := dataStore.DeleteProject(ctx, project.ID)
|
|
if err != nil {
|
|
t.Fatalf("delete project: %v", err)
|
|
}
|
|
if !deleted {
|
|
t.Fatalf("expected project deleted")
|
|
}
|
|
|
|
deletedProject, err := dataStore.GetProject(ctx, project.ID)
|
|
if err != nil {
|
|
t.Fatalf("get deleted project: %v", err)
|
|
}
|
|
if deletedProject != nil {
|
|
t.Fatalf("expected deleted project to be nil")
|
|
}
|
|
}
|
|
|
|
func TestCompletedWorkflowCannotBeRunAgainManually(t *testing.T) {
|
|
ctx := context.Background()
|
|
dataStore := store.NewMemoryStore()
|
|
|
|
project, err := dataStore.CreateProject(ctx, domain.CreateProjectInput{
|
|
Name: "只读项目",
|
|
Description: "completed workflow guard",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create project: %v", err)
|
|
}
|
|
|
|
workflow, err := dataStore.CreateWorkflow(ctx, domain.CreateWorkflowInput{
|
|
ProjectID: project.ID,
|
|
Name: "已完成工作流",
|
|
Description: "completed",
|
|
Type: domain.WorkflowTypeBatch,
|
|
Nodes: []domain.WorkflowNode{
|
|
{
|
|
ID: "node-1",
|
|
Type: "operator",
|
|
Data: domain.WorkflowNodeData{
|
|
Label: "真实数据源",
|
|
Category: "IO",
|
|
Description: "source",
|
|
},
|
|
Position: domain.Position{X: 0, Y: 0},
|
|
},
|
|
},
|
|
Edges: []domain.WorkflowEdge{},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create workflow: %v", err)
|
|
}
|
|
|
|
workflow.Status = domain.WorkflowStatusCompleted
|
|
if err := dataStore.UpsertWorkflow(ctx, *workflow); err != nil {
|
|
t.Fatalf("mark workflow completed: %v", err)
|
|
}
|
|
|
|
if _, err := dataStore.CreateRun(ctx, workflow.ID, domain.RunTriggerManual); err == nil {
|
|
t.Fatalf("expected manual rerun to be rejected")
|
|
} else if !errors.Is(err, store.ErrWorkflowAlreadyCompleted) {
|
|
t.Fatalf("expected ErrWorkflowAlreadyCompleted, got %v", err)
|
|
}
|
|
|
|
scheduledRun, err := dataStore.CreateRun(ctx, workflow.ID, domain.RunTriggerScheduled)
|
|
if err != nil {
|
|
t.Fatalf("expected scheduled run to remain allowed, got %v", err)
|
|
}
|
|
if scheduledRun == nil || scheduledRun.Status != domain.RunStatusQueued {
|
|
t.Fatalf("expected scheduled run queued, got %#v", scheduledRun)
|
|
}
|
|
}
|