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=2", "oops=2", 1), "duplicate config": strings.Replace(valid, "retries=2", "retries=2\nretries=1", 1), "invalid provider": strings.Replace(valid, "provider=opencode-go", "provider=not valid", 1), "invalid model": strings.Replace(valid, "model=deepseek-v4.1-flash", "model=not valid", 1), "bad retries": strings.Replace(valid, "retries=2", "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") } } }