150 lines
4.6 KiB
Go
150 lines
4.6 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"path/filepath"
|
|
"pipelines/internal/protocol"
|
|
"pipelines/internal/stage"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
func TestPersistenceAndAudit(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "pipelines.db")
|
|
s, err := Open(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx := context.Background()
|
|
source := Template([]string{"a", "b"}, true)
|
|
if v, err := s.Submit(ctx, "demo", source); err != nil || v != 1 {
|
|
t.Fatalf("v=%d err=%v", v, err)
|
|
}
|
|
if _, err := s.Submit(ctx, "demo", source); err == nil || err.Error() != "no changes" {
|
|
t.Fatalf("expected no changes, got %v", err)
|
|
}
|
|
if _, err := s.Submit(ctx, "demo", "invalid"); err == nil {
|
|
t.Fatal("accepted invalid source")
|
|
}
|
|
if _, err := s.Submit(ctx, "", source); err == nil {
|
|
t.Fatal("accepted empty name")
|
|
}
|
|
updated := strings.Replace(source, "Describe the task.", "Implement the request.", 1)
|
|
if v, err := s.Submit(ctx, "demo", updated); err != nil || v != 2 {
|
|
t.Fatalf("v=%d err=%v", v, err)
|
|
}
|
|
if err := s.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s, err = Open(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer s.Close()
|
|
var count int
|
|
if err := s.db.QueryRow("SELECT count(*) FROM pipeline_versions").Scan(&count); err != nil || count != 2 {
|
|
t.Fatalf("versions=%d err=%v", count, err)
|
|
}
|
|
if err := s.db.QueryRow("SELECT count(*) FROM submissions").Scan(&count); err != nil || count != 5 {
|
|
t.Fatalf("submissions=%d err=%v", count, err)
|
|
}
|
|
var original string
|
|
if err := s.db.QueryRow("SELECT source FROM pipeline_versions WHERE version=1").Scan(&original); err != nil || original != source {
|
|
t.Fatalf("original changed: %v", err)
|
|
}
|
|
if _, err := s.Submit(ctx, "demo", updated); err == nil || err.Error() != "no changes" {
|
|
t.Fatalf("restart: %v", err)
|
|
}
|
|
items, err := s.List(ctx)
|
|
if err != nil || len(items) != 1 {
|
|
t.Fatalf("list: %v %v", items, err)
|
|
}
|
|
item := items[0]
|
|
if item.Name != "demo" || item.Version != 2 || item.Stages != 2 || item.CreatedAt == "" || item.UpdatedAt == "" {
|
|
t.Fatalf("invalid summary: %+v", item)
|
|
}
|
|
latest, err := s.Get(ctx, item.ID, 0)
|
|
if err != nil || latest.Version != 2 || latest.Source != updated || len(latest.Versions) != 2 || latest.Versions[0].Version != 2 {
|
|
t.Fatalf("latest detail: %+v %v", latest, err)
|
|
}
|
|
old, err := s.Get(ctx, item.ID, 1)
|
|
if err != nil || old.Source != source || old.LatestVersion != 2 || old.ContentHash == "" || old.VersionCreatedAt == "" || len(old.Graph.Stages) != 2 {
|
|
t.Fatalf("historic detail: %+v %v", old, err)
|
|
}
|
|
for _, args := range []struct {
|
|
id int64
|
|
version int
|
|
}{{0, 0}, {item.ID, -1}, {item.ID, 99}, {9999, 0}} {
|
|
if _, err := s.Get(ctx, args.id, args.version); err == nil {
|
|
t.Fatalf("accepted invalid lookup: %+v", args)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConcurrentSubmissions(t *testing.T) {
|
|
s, err := Open(filepath.Join(t.TempDir(), "pipelines.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer s.Close()
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 5; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
_, err := s.Submit(context.Background(), "demo", Template([]string{"a"}, true))
|
|
if err != nil && err.Error() != "no changes" {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
var count int
|
|
if err := s.db.QueryRow("SELECT count(*) FROM pipeline_versions").Scan(&count); err != nil || count != 1 {
|
|
t.Fatalf("versions=%d err=%v", count, err)
|
|
}
|
|
}
|
|
|
|
func TestLegacyStageReadDoesNotRewriteHistory(t *testing.T) {
|
|
s, err := Open(filepath.Join(t.TempDir(), "pipelines.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer s.Close()
|
|
source := strings.NewReplacer(protocol.SuccessEnd, "#", protocol.FailureEnd, "#").Replace(Template([]string{"worker"}, true))
|
|
if _, err := s.Submit(context.Background(), "legacy", source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
graph, err := Parse(source)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
graph.Stages[0].Edges["success"] = "#"
|
|
graph.Stages[0].Edges["error"] = "#"
|
|
graph.Stages[0].Type = ""
|
|
old, err := json.Marshal(graph)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.db.Exec("UPDATE pipeline_versions SET graph_json=?", string(old)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, err := s.List(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
detail, err := s.Get(context.Background(), items[0].ID, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if detail.Source != source || detail.Graph.Stages[0].Type != stage.ModelType || detail.Graph.Stages[0].Edges["success"] != protocol.SuccessEnd || detail.Graph.Stages[0].Edges["error"] != protocol.FailureEnd {
|
|
t.Fatalf("invalid legacy detail: %+v", detail)
|
|
}
|
|
var persisted string
|
|
if err := s.db.QueryRow("SELECT graph_json FROM pipeline_versions").Scan(&persisted); err != nil || persisted != string(old) {
|
|
t.Fatalf("history was rewritten: %v", err)
|
|
}
|
|
}
|