79 lines
3.5 KiB
Go
79 lines
3.5 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestValidation(t *testing.T) {
|
|
valid := Template([]string{"implementer", "reviewer"}, true)
|
|
cycle := strings.Replace(valid, "success -> #success", "bad_implementation -> implementer\nsuccess -> #success", 1)
|
|
if _, err := Parse(cycle); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
withoutError := strings.ReplaceAll(valid, "error -> #failure\n", "")
|
|
graph, err := Parse(withoutError)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, stage := range graph.Stages {
|
|
if !stage.FallbackError || stage.Edges["error"] != protocol.FailureEnd {
|
|
t.Fatal("missing fallback")
|
|
}
|
|
}
|
|
for name, source := range map[string]string{
|
|
"missing block": strings.Replace(valid, "```output\nDescribe the output map.\n```", "", 1),
|
|
"retired input": valid + "```input\nold contract\n```\n",
|
|
"empty block": strings.Replace(valid, "Describe the output map.", " ", 1),
|
|
"duplicate block": valid + "```output\nagain\n```\n",
|
|
"unknown block": valid + "```foo\nx\n```\n",
|
|
"unclosed": valid + "```input\nx",
|
|
"duplicate stage": valid + valid,
|
|
"unknown target": strings.Replace(valid, "success -> reviewer", "success -> missing", 1),
|
|
"duplicate outcome": strings.Replace(valid, "success -> reviewer", "success -> reviewer\nsuccess -> #", 1),
|
|
"unknown config": strings.Replace(valid, "retries=0", "oops=2", 1),
|
|
"duplicate config": strings.Replace(valid, "retries=0", "retries=0\nretries=1", 1),
|
|
"unknown provider": strings.Replace(valid, "provider=opencode-go", "provider=unknown", 1),
|
|
"unknown model": strings.Replace(valid, "model=deepseek-v4.1-flash", "model=unknown", 1),
|
|
"old model typo": strings.Replace(valid, "model=deepseek-v4.1-flash", "model=deepseek-v4.1-flask", 1),
|
|
"bad retries": strings.Replace(valid, "retries=0", "retries=-1", 1),
|
|
"multiple targets": strings.Replace(valid, "success -> reviewer", "success -> reviewer, implementer", 1),
|
|
"unreachable": Template([]string{"a", "b"}, false),
|
|
"no termination": strings.NewReplacer("-> #success", "-> a", "-> #failure", "-> a").Replace(Template([]string{"a"}, true)),
|
|
"no stages": "",
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
if _, err := Parse(source); err == nil {
|
|
t.Fatal("accepted invalid definition")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSystemTerminalValidationAndLegacyAliases(t *testing.T) {
|
|
source := Template([]string{"worker"}, true)
|
|
for _, text := range []string{source, strings.NewReplacer(protocol.SuccessEnd, "#", protocol.FailureEnd, "#").Replace(source)} {
|
|
graph, err := Parse(text)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(graph.Stages) != 1 || graph.Stages[0].Edges["success"] != protocol.SuccessEnd || graph.Stages[0].Edges["error"] != protocol.FailureEnd {
|
|
t.Fatalf("invalid terminal normalization: %+v", graph)
|
|
}
|
|
}
|
|
graph, err := Parse(strings.ReplaceAll(source, "error -> #failure\n", ""))
|
|
if err != nil || graph.Stages[0].Edges["error"] != protocol.FailureEnd || !graph.Stages[0].FallbackError {
|
|
t.Fatalf("error fallback: %+v %v", graph, err)
|
|
}
|
|
graph, err = Parse(strings.Replace(source, "success -> #success", "rejected -> #failure", 1))
|
|
if err != nil || graph.Stages[0].Edges["rejected"] != protocol.FailureEnd {
|
|
t.Fatalf("custom failure outcome: %+v %v", graph, err)
|
|
}
|
|
for _, invalid := range []string{strings.Replace(source, "success -> #success", "success -> #unknown", 1), strings.Replace(source, "# stage worker", "# stage #failure", 1)} {
|
|
if _, err := Parse(invalid); err == nil {
|
|
t.Fatal("accepted invalid system terminal")
|
|
}
|
|
}
|
|
}
|