diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go
index 46b2862e5..28f7fcf59 100644
--- a/internal/app/archied/bootstrap.go
+++ b/internal/app/archied/bootstrap.go
@@ -764,20 +764,26 @@ func (b *boot) loadModules(cfg config.Config, log *slog.Logger) error {
}
// loadEDAPlaybooks loads the EDA playbook documents (t2db.15): trigger +
-// single workflow-kind action with CEL when conditions and args values.
-// Loaded at startup with the same reject-at-load rule -- any malformed
-// playbook, multi-action playbook, non-workflow position, when compile
-// failure, or args compile failure aborts startup, matching the routing-file
-// load pattern (not degrade-and-skip). A nonexistent dir is an empty store.
-// Split out of loadWorkflows (t2db.16); pure extraction, same log messages as
-// before.
+// workflow-kind actions and module-kind action playbooks with CEL when
+// conditions and args values. Loaded at startup with the same reject-at-load
+// rule -- any malformed playbook, mixed/unsupported action shape, unknown
+// module kind, when compile failure, or args key failure aborts startup,
+// matching the routing-file load pattern (not degrade-and-skip). A nonexistent
+// dir is an empty store. Action playbooks load and type-check but have no run
+// path yet (t2db.31), so each one is logged as a visible warning here rather
+// than routed by the definition pin.
func (b *boot) loadEDAPlaybooks(cfg config.Config, log *slog.Logger) error {
var err error
- b.playbooks, err = playbook.Load(cfg.EDAPlaybookDir)
+ b.playbooks, err = playbook.Load(cfg.EDAPlaybookDir, b.modules)
if err != nil {
log.Error("eda playbook load failed", "dir", cfg.EDAPlaybookDir, "err", err)
return err
}
+ for _, pb := range b.playbooks.Playbooks {
+ if len(pb.Actions) != 1 || pb.Actions[0].Position != "workflow" {
+ log.Warn("eda action playbook loaded: action playbooks do not execute yet", "playbook", pb.ID)
+ }
+ }
log.Info("eda playbooks loaded", "dir", cfg.EDAPlaybookDir, "playbooks", len(b.playbooks.Playbooks))
return nil
}
diff --git a/internal/app/archied/eda_playbooks_test.go b/internal/app/archied/eda_playbooks_test.go
new file mode 100644
index 000000000..993029ab5
--- /dev/null
+++ b/internal/app/archied/eda_playbooks_test.go
@@ -0,0 +1,50 @@
+package archied
+
+import (
+ "bytes"
+ "log/slog"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "github.com/samcharles93/archie-core/internal/config"
+ "github.com/samcharles93/archie-core/internal/domain/eda/module"
+)
+
+// TestLoadEDAPlaybooksWarnsOnActionPlaybook pins the D1 visible warning: an
+// action playbook loads and validates but has no run path yet, so the daemon
+// logs a warning (not debug) naming it and stating plainly that action
+// playbooks do not execute yet -- rather than silently loading a playbook that
+// can never be routed.
+func TestLoadEDAPlaybooksWarnsOnActionPlaybook(t *testing.T) {
+ dir := t.TempDir()
+ if err := os.WriteFile(filepath.Join(dir, "pb.yaml"), []byte(`trigger:
+ kind: bug
+actions:
+ - position: module
+ kind: log
+ args:
+ message: '"build started"'
+`), 0o600); err != nil {
+ t.Fatal(err)
+ }
+
+ var buf bytes.Buffer
+ log := slog.New(slog.NewTextHandler(&buf, nil))
+ b := &boot{cfg: config.Config{EDAPlaybookDir: dir}, modules: module.New()}
+ if err := b.loadEDAPlaybooks(b.cfg, log); err != nil {
+ t.Fatalf("loadEDAPlaybooks: %v", err)
+ }
+
+ out := buf.String()
+ if !strings.Contains(out, "pb.yaml") {
+ t.Errorf("warning output does not name the action playbook: %q", out)
+ }
+ if !strings.Contains(out, "do not execute yet") {
+ t.Errorf("warning output does not state action playbooks do not execute yet: %q", out)
+ }
+ if strings.Contains(out, "level=DEBUG") {
+ t.Errorf("warning output was logged at debug, want a visible warning: %q", out)
+ }
+}
diff --git a/internal/daemon/playbook_dispatch_test.go b/internal/daemon/playbook_dispatch_test.go
index f123c059d..feab28f23 100644
--- a/internal/daemon/playbook_dispatch_test.go
+++ b/internal/daemon/playbook_dispatch_test.go
@@ -7,6 +7,7 @@ import (
"strings"
"testing"
+ "github.com/samcharles93/archie-core/internal/domain/eda/module"
"github.com/samcharles93/archie-core/internal/domain/eda/playbook"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/store"
@@ -20,7 +21,7 @@ func playbookStore(t *testing.T, document string) *playbook.Store {
if err := os.WriteFile(filepath.Join(dir, "pb.yaml"), []byte(document), 0o600); err != nil {
t.Fatal(err)
}
- loaded, err := playbook.Load(dir)
+ loaded, err := playbook.Load(dir, module.New())
if err != nil {
t.Fatalf("load playbook: %v", err)
}
diff --git a/internal/domain/eda/expr/expr.go b/internal/domain/eda/expr/expr.go
index a4471f35d..6e0254657 100644
--- a/internal/domain/eda/expr/expr.go
+++ b/internal/domain/eda/expr/expr.go
@@ -259,22 +259,24 @@ func (e *Env) Compile(src string) (*Program, error) {
// the `actions` context root as either a statically-resolvable action id or
// not. The invariant is exhaustive by construction: each read of `actions`
// consumes exactly one `actions` identifier node, so counting identifier
-// nodes and counting the reads that match one of the two static access
-// shapes (a field selection on the `actions` ident, or a map index whose key
-// is a string literal) yields
+// nodes and counting the reads that match the static access shape (a field
+// selection on the `actions` ident) yields
//
// resolvable = (identCount == staticCount)
//
// Any other spelling that mentions `actions` contributes an identifier node
// without a matching static access, so it reports unresolvable rather than
// slipping through as a runtime miss. The returned ids are the sorted,
-// de-duplicated ids of the static accesses, for the playbook loader's
-// unknown-id check.
+// de-duplicated ids of the static accesses.
//
-// With the per-playbook object type the checker already rejects every
-// non-static `actions` read at compile time, so a program that reaches this
-// walk is resolvable by construction; the walk is retained until the next
-// pass removes it together with the loader's duplicate unknown-id check.
+// With the per-playbook object type the CEL checker rejects every non-static
+// `actions` read at compile time -- a dynamic index, `in`, `size`, or a
+// method/field selection that is not a declared id never reaches this walk.
+// The one spelling the checker does NOT reject is a bare `actions` value
+// read, which compiles as an object value but cannot be pinned to an action
+// id at load. This walk is retained solely to reject that spelling; the ids
+// return is now informational (the unknown-id check moved to the checker's
+// per-playbook object type).
func actionReferences(ast *cel.Ast) ([]string, bool) {
if ast == nil || ast.NativeRep() == nil {
return nil, true
@@ -294,24 +296,6 @@ func actionReferences(ast *cel.Ast) ([]string, bool) {
}
staticCount++
seen[sel.FieldName()] = struct{}{}
- case celast.CallKind:
- call := e.AsCall()
- if call.FunctionName() != "_[_]" || len(call.Args()) != 2 {
- return
- }
- if !isActionsIdent(call.Args()[0]) {
- return
- }
- key := call.Args()[1]
- if key.Kind() != celast.LiteralKind {
- return
- }
- id, ok := key.AsLiteral().Value().(string)
- if !ok {
- return
- }
- staticCount++
- seen[id] = struct{}{}
}
})
celast.PreOrderVisit(ast.NativeRep().Expr(), visitor)
@@ -340,8 +324,10 @@ type Program struct {
// read could be statically resolved to one of those ids. ids is empty when
// the expression reads no prior-action result; resolvable is false when the
// expression reads `actions` in any form that cannot be pinned to a prior
-// action id at load. The playbook loader rejects a non-resolvable program
-// rather than evaluating it as a runtime miss.
+// action id at load. Under the per-playbook object type the checker already
+// rejects every dynamic `actions` read, so the only form that still reaches
+// here unresolved is a bare `actions` value read; the playbook loader rejects
+// that rather than evaluating it as a runtime miss.
func (p *Program) ActionReferences() (ids []string, resolvable bool) {
if p == nil {
return nil, true
diff --git a/internal/domain/eda/module/module.go b/internal/domain/eda/module/module.go
index d584b9885..af19b51a5 100644
--- a/internal/domain/eda/module/module.go
+++ b/internal/domain/eda/module/module.go
@@ -36,6 +36,12 @@ type Kind struct {
// exportPath is the fixed exported function name the interpreted file
// must define (e.g. "main.Run").
exportPath string
+ // argsType and resultType are the kind's hand-written Args and Result
+ // struct types. They are the schema the playbook loader declares to CEL
+ // so an arg key or result field typo is a load failure rather than a
+ // dispatch failure (multi-action-playbooks.md, D4).
+ argsType reflect.Type
+ resultType reflect.Type
}
// registry maps kind name to its one typed contract. Adding a new kind is a
@@ -44,6 +50,8 @@ var registry = map[string]Kind{
"log": {
loadSymbols: func() map[string]map[string]reflect.Value { return logextract.Symbols },
exportPath: "main.Run",
+ argsType: reflect.TypeFor[log.Args](),
+ resultType: reflect.TypeFor[log.Result](),
},
}
@@ -82,6 +90,20 @@ func (r *ModuleRegistry) Len() int {
return len(r.kinds)
}
+// KindSchema reports the hand-written Args and Result struct types for a
+// known kind. A kind is known when it has a registered contract in this
+// package's built-in registry (the log kind is the shipped kind), independent
+// of whether a module instance is currently loaded from a module directory.
+// It is the narrow schema source the playbook loader consumes to type-check
+// an action playbook's args and result references at load.
+func (r *ModuleRegistry) KindSchema(kind string) (reflect.Type, reflect.Type, bool) {
+ k, ok := registry[kind]
+ if !ok {
+ return nil, nil, false
+ }
+ return k.argsType, k.resultType, true
+}
+
// Register discovers
/.go, interprets it against the kind's
// generated symbols, resolves its fixed export, and stores the invoker.
// A missing file, an unreadable file, a resolve failure, or an unknown kind
diff --git a/internal/domain/eda/module/module_test.go b/internal/domain/eda/module/module_test.go
index 2dfbd579f..bea77589e 100644
--- a/internal/domain/eda/module/module_test.go
+++ b/internal/domain/eda/module/module_test.go
@@ -4,8 +4,11 @@ import (
"context"
"os"
"path/filepath"
+ "reflect"
"strings"
"testing"
+
+ "github.com/samcharles93/archie-core/internal/domain/eda/module/log"
)
func writeModule(t *testing.T, dir, content string) string {
@@ -58,6 +61,23 @@ func TestRegisterUnknownKindIsError(t *testing.T) {
}
}
+func TestKindSchema(t *testing.T) {
+ r := New()
+ argsType, resultType, ok := r.KindSchema("log")
+ if !ok {
+ t.Fatal("KindSchema(log) = not ok, want the built-in log contract")
+ }
+ if argsType != reflect.TypeFor[log.Args]() {
+ t.Errorf("KindSchema(log) args = %v, want log.Args", argsType)
+ }
+ if resultType != reflect.TypeFor[log.Result]() {
+ t.Errorf("KindSchema(log) result = %v, want log.Result", resultType)
+ }
+ if _, _, ok := r.KindSchema("notify"); ok {
+ t.Fatal("KindSchema(notify) = ok, want false for an unregistered kind")
+ }
+}
+
func TestRegisterMissingFileIsError(t *testing.T) {
r := New()
if err := r.Register("log", t.TempDir()); err == nil {
diff --git a/internal/domain/eda/playbook/coordinator_test.go b/internal/domain/eda/playbook/coordinator_test.go
index 9b7a8ec5a..211f5ac21 100644
--- a/internal/domain/eda/playbook/coordinator_test.go
+++ b/internal/domain/eda/playbook/coordinator_test.go
@@ -142,7 +142,7 @@ actions:
workflow: tdd
id: notify
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
diff --git a/internal/domain/eda/playbook/playbook.go b/internal/domain/eda/playbook/playbook.go
index 8414bdf7f..36b45ce33 100644
--- a/internal/domain/eda/playbook/playbook.go
+++ b/internal/domain/eda/playbook/playbook.go
@@ -1,16 +1,20 @@
// Package playbook is the EDA playbook document type and its event
// coordinator: the rich trigger+actions YAML shape (docs/prds/
// eda-playbook-engine.md) with CEL `when` conditions and `args` values
-// (open question 1, resolved to CEL). This slice is deliberately single-action,
-// workflow-position only: multi-action playbooks and Module/Channel/Forge
-// action positions remain blocked on the unresolved execution-time gaps
-// (mid-run failure semantics, idempotency for non-workflow actions) and are
-// rejected at load -- the hard boundary, not to be relaxed without sign-off.
+// (open question 1, resolved to CEL). A playbook is one of two shapes
+// (multi-action-playbooks.md, D2):
//
-// This is an ADDITIONAL routing source alongside the flat kind/label binding
-// files (t2db.9/.10/.11): the daemon consults a matching playbook before
-// those bindings when it pins a task's workflow definition (t2db.23). The
-// binding loaders themselves are untouched.
+// - a workflow playbook is exactly one `workflow` action, unchanged from
+// the original boundary, and is routed by the daemon's definition pin;
+// - an action playbook is one or more `module` actions in order, each with
+// a registered `kind`, `args`, and an optional `when`/`id`. It loads and
+// type-checks now but has no run path yet (t2db.31).
+//
+// The two shapes never mix in one playbook. This is an ADDITIONAL routing
+// source alongside the flat kind/label binding files (t2db.9/.10/.11): the
+// daemon consults a matching workflow playbook before those bindings when it
+// pins a task's workflow definition (t2db.23). The binding loaders themselves
+// are untouched.
package playbook
import (
@@ -18,6 +22,7 @@ import (
"fmt"
"os"
"path/filepath"
+ "reflect"
"regexp"
"sort"
"strings"
@@ -28,10 +33,19 @@ import (
"github.com/samcharles93/archie-core/internal/domain/workintake"
)
+// KindSchemas is the narrow kind-to-schema source the loader consults to
+// type-check an action playbook: each module kind's hand-written Args and
+// Result struct types. *module.ModuleRegistry satisfies it, so the playbook
+// package grows no import of the module package.
+type KindSchemas interface {
+ // KindSchema reports the Args and Result reflect types for a known kind;
+ // ok is false when kind is not a registered module kind.
+ KindSchema(kind string) (args, result reflect.Type, ok bool)
+}
+
// Store is the loaded set of playbooks, validated and compiled at load time.
type Store struct {
Playbooks []*Playbook
- exprEnv *expr.Env
}
// Playbook is one trigger+actions document.
@@ -65,8 +79,9 @@ type Trigger struct {
Labels []string
}
-// Action is one step in a playbook. Exactly one action per playbook in this
-// slice, position MUST be "workflow".
+// Action is one step in a playbook. A workflow action names a workflow
+// definition; a module action names a registered module kind and is not
+// routed yet.
type Action struct {
Position string
// ID is an optional stable identifier for this action. When present it
@@ -74,6 +89,9 @@ type Action struct {
// (actions.); the shape is the shared stable-identifier grammar
// (internal/plugin/host.go, internal/domain/workflow/vocabulary.go).
ID string
+ // Kind is the module kind name (position: module only); empty for a
+ // workflow action.
+ Kind string
// Workflow is the name of the workflow definition to dispatch to
// (position: workflow only).
Workflow string
@@ -82,6 +100,13 @@ type Action struct {
// Args holds the action's compiled CEL args values, keyed by arg name.
// Nil or empty means the action takes no args.
Args map[string]*expr.Program
+
+ // env is the per-action CEL environment this action's expressions were
+ // compiled against: the prior actions' declared ids and their kinds'
+ // Result types. It is also the eval receiver for When/Args. It is unset
+ // only for a hand-built Action (tests, pre-load composition); loaded
+ // actions always carry it.
+ env *expr.Env
}
// rawPlaybook is the YAML document shape before compilation.
@@ -113,9 +138,9 @@ var actionIDPattern = regexp.MustCompile(`^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$`)
// validateActionIDs enforces the id shape and uniqueness across a playbook's
// raw actions. An absent id is fine (ids are optional); a declared id must
-// match the stable-identifier grammar and may not repeat. Uniqueness is
-// unreachable through Load while the one-action boundary holds, so this helper
-// is unit-tested directly for the duplicate case.
+// match the stable-identifier grammar and may not repeat. With action
+// playbooks now loadable, duplicate ids are reachable through Load, so this
+// helper is the load-boundary's id gate for both shapes.
func validateActionIDs(actions []rawAction) error {
seen := make(map[string]struct{}, len(actions))
for _, a := range actions {
@@ -134,37 +159,18 @@ func validateActionIDs(actions []rawAction) error {
return nil
}
-// unknownActionReference returns the first statically-resolved action id a
-// compiled `when` reads that is not declared on any action before index idx.
-// The comparison is against earlier actions' declared ids (the general rule
-// from J1), so it stays correct when the one-action boundary later relaxes;
-// today idx is always 0, so any actions. reference is unknown.
-func unknownActionReference(raw []rawAction, idx int, ids []string) (string, bool) {
- declared := make(map[string]struct{}, idx)
- for _, prior := range raw[:idx] {
- if prior.ID != "" {
- declared[prior.ID] = struct{}{}
- }
- }
- for _, id := range ids {
- if _, ok := declared[id]; !ok {
- return id, true
- }
- }
- return "", false
-}
-
// Load reads every *.yaml/*.yml playbook in dir, validates each against the
-// hard boundary (exactly one action, position workflow), and compiles each
-// when expression and args value. ANY failure -- malformed YAML, a
-// multi-action playbook, a non-workflow position, a when compile error, an
-// args compile error -- fails the whole load: the reject-at-load philosophy
-// of the parent design doc. A missing directory is an empty store (matching
-// the flat binding loaders' convention).
-func Load(dir string) (*Store, error) {
+// two-shape boundary (exactly one workflow action, or one or more module
+// actions; never mixed), and compiles each when expression and args value
+// against the action's per-playbook environment. ANY failure -- malformed
+// YAML, a mixed/unsupported/empty action shape, an unknown kind, a when
+// compile error, an args key error -- fails the whole load: the reject-at-load
+// philosophy of the parent design doc. A missing directory is an empty store
+// (matching the flat binding loaders' convention).
+func Load(dir string, schemas KindSchemas) (*Store, error) {
entries, err := os.ReadDir(dir)
if os.IsNotExist(err) {
- return &Store{exprEnv: expr.NewEnv()}, nil
+ return &Store{}, nil
}
if err != nil {
return nil, fmt.Errorf("read playbook dir %s: %w", dir, err)
@@ -181,10 +187,10 @@ func Load(dir string) (*Store, error) {
}
sort.Strings(names)
- store := &Store{exprEnv: expr.NewEnv()}
+ store := &Store{}
for _, name := range names {
path := filepath.Join(dir, name)
- pb, err := loadOne(dir, path, store.exprEnv)
+ pb, err := loadOne(dir, path, schemas)
if err != nil {
return nil, err
}
@@ -195,7 +201,7 @@ func Load(dir string) (*Store, error) {
// loadOne loads and validates a single playbook file, deriving its stable ID
// (path relative to the configured root) and a content-hash Version.
-func loadOne(dir, path string, env *expr.Env) (*Playbook, error) {
+func loadOne(dir, path string, schemas KindSchemas) (*Playbook, error) {
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("read playbook %s: %w", path, err)
@@ -226,73 +232,157 @@ func loadOne(dir, path string, env *expr.Env) (*Playbook, error) {
if err := pb.Trigger.Kind.Validate(); err != nil {
return nil, fmt.Errorf("playbook %s: %w", path, err)
}
-
- // HARD BOUNDARY (t2db.15): exactly one action, position workflow only.
- if len(raw.Actions) != 1 {
- return nil, fmt.Errorf(
- "playbook %s: exactly one action is supported; got %d (multi-action playbooks are blocked on unresolved execution-time gaps)",
- path, len(raw.Actions),
- )
- }
- a := raw.Actions[0]
- b := "workflow"
- if a.Position == "" {
- // Default position for a single bare workflow name stays workflow for
- // the smallest-useful case.
- a.Position = b
- }
- if a.Position != b {
- return nil, fmt.Errorf(
- "playbook %s: action position %q is not supported; only %q actions ship (Module/Channel/Forge positions are blocked on unresolved execution-time gaps)",
- path, a.Position, b,
- )
- }
- if strings.TrimSpace(a.Workflow) == "" {
- return nil, fmt.Errorf("playbook %s: workflow-kind action must name a workflow", path)
- }
if err := validateActionIDs(raw.Actions); err != nil {
return nil, fmt.Errorf("playbook %s: %w", path, err)
}
+ actions, err := compileActions(path, raw.Actions, schemas)
+ if err != nil {
+ return nil, err
+ }
+ pb.Actions = actions
+ return pb, nil
+}
+
+// compileActions validates the action shape (D2) and compiles every action's
+// expressions against that action's environment of prior results. Exactly one
+// workflow action is a workflow playbook; one or more module actions is an
+// action playbook; anything else fails the load naming the playbook.
+func compileActions(path string, raw []rawAction, schemas KindSchemas) ([]Action, error) {
+ if len(raw) == 0 {
+ return nil, fmt.Errorf("playbook %s: must declare at least one action", path)
+ }
+
+ var workflows, modules int
+ for i := range raw {
+ a := &raw[i]
+ pos := strings.TrimSpace(a.Position)
+ if pos == "" {
+ // Default position for a single bare workflow name stays workflow
+ // for the smallest-useful case.
+ if len(raw) == 1 && strings.TrimSpace(a.Workflow) != "" {
+ pos = "workflow"
+ } else {
+ return nil, fmt.Errorf("playbook %s: action %d must declare a position (%q or %q)", path, i+1, "workflow", "module")
+ }
+ }
+ if pos != "workflow" && pos != "module" {
+ return nil, fmt.Errorf("playbook %s: action %d position %q is not supported (want %q or %q)", path, i+1, pos, "workflow", "module")
+ }
+ a.Position = pos
+ if pos == "workflow" {
+ workflows++
+ } else {
+ modules++
+ }
+ }
+
+ switch {
+ case workflows > 0 && modules > 0:
+ return nil, fmt.Errorf("playbook %s: cannot mix workflow and module actions in one playbook", path)
+ case workflows > 0:
+ if workflows != 1 {
+ return nil, fmt.Errorf("playbook %s: exactly one workflow action is supported; got %d", path, workflows)
+ }
+ return compileWorkflowActions(path, raw)
+ default:
+ return compileModuleActions(path, raw, schemas)
+ }
+}
+
+// compileWorkflowActions builds the single-action workflow playbook shape.
+// The env has no prior result ids, so a workflow `when` or `args` value that
+// reads `actions.` fails at compile -- the unchanged workflow behaviour.
+func compileWorkflowActions(path string, raw []rawAction) ([]Action, error) {
+ a := raw[0]
+ if strings.TrimSpace(a.Workflow) == "" {
+ return nil, fmt.Errorf("playbook %s: workflow-kind action must name a workflow", path)
+ }
+
+ env := expr.NewEnv()
action := Action{
- Position: a.Position,
+ Position: "workflow",
ID: a.ID,
Workflow: strings.TrimSpace(a.Workflow),
+ env: env,
}
if strings.TrimSpace(a.When) != "" {
- prg, err := compileWhen(path, a.When, env, raw.Actions)
+ prg, err := compileExpr(path, "when condition", a.When, env)
if err != nil {
return nil, err
}
action.When = prg
}
- args, err := compileArgs(path, a.Args, env, raw.Actions)
+ args, err := compileArgs(path, "", a.Args, env, nil)
if err != nil {
return nil, err
}
action.Args = args
- pb.Actions = []Action{action}
- return pb, nil
+ return []Action{action}, nil
}
-// compileWhen compiles a raw `when` expression and validates its action
-// references against the actions declared before it. The wording of the
-// returned errors is the loader's existing contract, preserved verbatim by
-// passing the `when condition` field label to compileExpr.
-func compileWhen(path, when string, env *expr.Env, prior []rawAction) (*expr.Program, error) {
- return compileExpr(path, "when condition", when, env, prior)
+// compileModuleActions builds the one-or-more-module-actions playbook shape.
+// Each action's env declares the prior actions' ids typed by their kinds'
+// Result structs, so a later action can read an earlier result and a forward
+// or field-typo read fails at compile (multi-action-playbooks.md, D3).
+func compileModuleActions(path string, raw []rawAction, schemas KindSchemas) ([]Action, error) {
+ actions := make([]Action, 0, len(raw))
+ var declared []expr.DeclaredResult
+ for _, a := range raw {
+ kind := strings.TrimSpace(a.Kind)
+ if kind == "" {
+ return nil, fmt.Errorf("playbook %s: module-kind action must name a kind", path)
+ }
+ argsType, resultType, ok := schemas.KindSchema(kind)
+ if !ok {
+ return nil, fmt.Errorf("playbook %s: unknown module kind %q", path, kind)
+ }
+
+ env := expr.NewEnv(declared...)
+ action := Action{
+ Position: "module",
+ ID: a.ID,
+ Kind: kind,
+ env: env,
+ }
+ if strings.TrimSpace(a.When) != "" {
+ prg, err := compileExpr(path, "when condition", a.When, env)
+ if err != nil {
+ return nil, err
+ }
+ action.When = prg
+ }
+ args, err := compileArgs(path, kind, a.Args, env, argsType)
+ if err != nil {
+ return nil, err
+ }
+ action.Args = args
+ actions = append(actions, action)
+
+ if a.ID != "" {
+ declared = append(declared, expr.DeclaredResult{ID: a.ID, Type: resultType})
+ }
+ }
+ return actions, nil
}
// compileArgs compiles every args value as a CEL expression at load, keyed by
// arg name. J2 has no literal/expression split: the YAML scalar text IS the
// CEL source, so a string literal is quoted inside YAML and a number or
-// context read is written as CEL. Each program goes through the same
+// context read is written as CEL. When argsSchema is non-nil (a module kind's
+// Args struct) every key must name one of its fields; workflow actions pass
+// nil and keep free-form args. Each program goes through the same
// compile/reference validation as `when`, with the field label naming the
// offending args key.
-func compileArgs(path string, raw map[string]string, env *expr.Env, prior []rawAction) (map[string]*expr.Program, error) {
+func compileArgs(path, kind string, raw map[string]string, env *expr.Env, argsSchema reflect.Type) (map[string]*expr.Program, error) {
if len(raw) == 0 {
return nil, nil
}
+ if argsSchema != nil {
+ if err := validateArgsKeys(path, kind, argsSchema, raw); err != nil {
+ return nil, err
+ }
+ }
keys := make([]string, 0, len(raw))
for key := range raw {
keys = append(keys, key)
@@ -300,7 +390,7 @@ func compileArgs(path string, raw map[string]string, env *expr.Env, prior []rawA
sort.Strings(keys)
args := make(map[string]*expr.Program, len(raw))
for _, key := range keys {
- prg, err := compileExpr(path, fmt.Sprintf("args[%q]", key), raw[key], env, prior)
+ prg, err := compileExpr(path, fmt.Sprintf("args[%q]", key), raw[key], env)
if err != nil {
return nil, err
}
@@ -309,27 +399,47 @@ func compileArgs(path string, raw map[string]string, env *expr.Env, prior []rawA
return args, nil
}
-// compileExpr compiles one playbook expression and applies the two load-time
-// reference checks: every `actions` read must be statically resolvable to a
-// prior action id, and every resolved id must be declared on an earlier
-// action. field is the human-readable expression location used in errors
-// (`when condition` or `args["name"]`), so a failure names the playbook path
-// and the offending expression.
-func compileExpr(path, field, src string, env *expr.Env, prior []rawAction) (*expr.Program, error) {
+// validateArgsKeys rejects an args key the kind's Args struct does not define
+// (multi-action-playbooks.md, D4), so an arg typo is a load failure rather
+// than a dispatch-time shape mismatch. Go field names are lower-cased to the
+// YAML spelling (Message -> message), matching the module's strict decode.
+func validateArgsKeys(path, kind string, argsSchema reflect.Type, raw map[string]string) error {
+ t := argsSchema
+ if t.Kind() == reflect.Pointer {
+ t = t.Elem()
+ }
+ fields := make(map[string]struct{}, t.NumField())
+ for field := range t.Fields() {
+ fields[strings.ToLower(field.Name)] = struct{}{}
+ }
+ for key := range raw {
+ if _, ok := fields[strings.ToLower(key)]; !ok {
+ return fmt.Errorf("playbook %s: %s kind args[%q] is not a declared Args field", path, kind, key)
+ }
+ }
+ return nil
+}
+
+// compileExpr compiles one playbook expression and applies the remaining
+// load-time reference check: every `actions` read must be statically
+// resolvable to a prior action id. The per-playbook object type rejects an
+// undeclared or forward id and a dynamic `actions` read at compile time; the
+// one spelling it does not reject is a bare `actions` value read, which this
+// check still refuses. field is the human-readable expression location used in
+// errors (`when condition` or `args["name"]`), so a failure names the
+// playbook path and the offending expression.
+func compileExpr(path, field, src string, env *expr.Env) (*expr.Program, error) {
prg, err := env.Compile(strings.TrimSpace(src))
if err != nil {
return nil, fmt.Errorf("playbook %s: %s: %w", path, field, err)
}
- ids, resolvable := prg.ActionReferences()
+ _, resolvable := prg.ActionReferences()
if !resolvable {
return nil, fmt.Errorf(
"playbook %s: %s contains an `actions` reference that cannot be statically resolved to an action id (the `actions` context root must be read as a prior action id)",
path, field,
)
}
- if id, unknown := unknownActionReference(prior, 0, ids); unknown {
- return nil, fmt.Errorf("playbook %s: %s references unknown action id %q", path, field, id)
- }
return prg, nil
}
@@ -401,8 +511,11 @@ type Decision struct {
ActionPosition int
}
-// Dispatch returns the workflow name the first matching playbook selects for
-// the input, and whether any playbook matched. No match means trigger
+// Dispatch returns the workflow name the first matching workflow playbook
+// selects for the input, and whether any playbook matched. Action playbooks
+// are loaded and validated but not routed (multi-action-playbooks.md, D1), so
+// this considers workflow playbooks only: an action playbook cannot hijack the
+// definition pin before its run path exists (t2db.31). No match means trigger
// mismatch or a when condition evaluating false, and the caller keeps its own
// routing.
//
@@ -426,9 +539,13 @@ func (s *Store) Dispatch(input DispatchInput) (Decision, bool) {
if !pb.Match(input) {
continue
}
+ if len(pb.Actions) != 1 || pb.Actions[0].Position != "workflow" {
+ // Action playbook: loaded and validated, not routed (D1).
+ continue
+ }
a := pb.Actions[0]
if a.When != nil {
- val, err := s.exprEnv.Eval(a.When, ctx)
+ val, err := a.env.Eval(a.When, ctx)
if err != nil {
// J3: evaluation error -> false (skip), caller logs.
continue
@@ -479,7 +596,7 @@ func (s *Store) EvalArgs(a Action, input DispatchInput) (map[string]any, error)
if a.Args[key] == nil {
continue
}
- val, err := s.exprEnv.Eval(a.Args[key], ctx)
+ val, err := a.env.Eval(a.Args[key], ctx)
if err != nil {
return nil, fmt.Errorf("evaluate args[%q]: %w", key, err)
}
diff --git a/internal/domain/eda/playbook/playbook_test.go b/internal/domain/eda/playbook/playbook_test.go
index 176dab19e..720f0e73d 100644
--- a/internal/domain/eda/playbook/playbook_test.go
+++ b/internal/domain/eda/playbook/playbook_test.go
@@ -10,6 +10,7 @@ import (
"testing"
"github.com/samcharles93/archie-core/internal/domain/eda/expr"
+ "github.com/samcharles93/archie-core/internal/domain/eda/module"
)
func writeFile(t *testing.T, dir, name, content string) string {
@@ -24,6 +25,15 @@ func writeFile(t *testing.T, dir, name, content string) string {
return path
}
+// testSchemas is the real module kind-schema source the loader consults in
+// tests: *module.ModuleRegistry satisfies playbook.KindSchemas. It consults
+// the built-in kind registry, so no module file needs to be installed for the
+// schema lookup to work.
+func testSchemas(t *testing.T) KindSchemas {
+ t.Helper()
+ return module.New()
+}
+
// TestLoadSingleWorkflowActionRoundTrip: a playbook with trigger + one
// workflow-kind action + optional when loads and dispatches to the correct
// registered workflow when trigger+when match.
@@ -37,7 +47,7 @@ actions:
workflow: tdd
when: event.priority == 3
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -78,7 +88,7 @@ actions:
workflow: tdd
when: event.priority == 5
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -105,32 +115,49 @@ actions:
- position: workflow
workflow: implement
`)
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatal("Load(2 actions) = nil, want load failure")
}
- if !strings.Contains(err.Error(), "exactly one action") {
- t.Errorf("Load error = %q, want the one-action rule named", err.Error())
+ if !strings.Contains(err.Error(), "exactly one workflow action") {
+ t.Errorf("Load error = %q, want the one-workflow-action rule named", err.Error())
}
}
-// TestLoadNonWorkflowPositionIsLoadFailure: a playbook with a non-workflow
-// action position is a reported load failure.
-func TestLoadNonWorkflowPositionIsLoadFailure(t *testing.T) {
+// TestLoadModuleActionIsValidActionPlaybook: one module action is now a valid
+// action playbook shape (one or more module actions in order).
+func TestLoadModuleActionIsValidActionPlaybook(t *testing.T) {
dir := t.TempDir()
writeFile(t, dir, "pb.yaml", `
trigger:
kind: bug
actions:
- - position: module
+ - id: build
+ position: module
kind: log
+ args:
+ message: '"build started"'
`)
- _, err := Load(dir)
- if err == nil {
- t.Fatal("Load(module action) = nil, want load failure")
+ store, err := Load(dir, testSchemas(t))
+ if err != nil {
+ t.Fatalf("Load(module action) = %v, want a valid action playbook", err)
}
- if !strings.Contains(err.Error(), "workflow") {
- t.Errorf("Load error = %q, want the position restriction named", err.Error())
+ if len(store.Playbooks) != 1 {
+ t.Fatalf("loaded %d playbooks, want 1", len(store.Playbooks))
+ }
+ a := store.Playbooks[0].Actions[0]
+ if a.Position != "module" || a.Kind != "log" {
+ t.Errorf("action = (%q, %q), want (module, log)", a.Position, a.Kind)
+ }
+ if a.ID != "build" {
+ t.Errorf("action id = %q, want build", a.ID)
+ }
+ if len(a.Args) != 1 || a.Args["message"] == nil {
+ t.Errorf("Action.Args = %#v, want the message program compiled", a.Args)
+ }
+ // Action playbooks are loaded and validated but not routed (D1).
+ if decision, ok := store.Dispatch(DispatchInput{Kind: "bug", Event: map[string]any{}}); ok {
+ t.Fatalf("Dispatch(action playbook) = %v, want no match (not routed)", decision)
}
}
@@ -147,7 +174,7 @@ actions:
workflow: tdd
when: event.label ==
`)
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatal("Load(bad when) = nil, want compile failure reported")
}
@@ -168,7 +195,7 @@ actions:
- position: workflow
workflow: tdd
`)
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatal("Load(no trigger) = nil, want load failure")
}
@@ -185,7 +212,7 @@ actions:
- position: workflow
workflow: tdd
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -210,7 +237,7 @@ actions:
- position: workflow
workflow: tdd
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -245,7 +272,7 @@ actions:
- position: workflow
workflow: implement
`)
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatal("Load(dir with one bad playbook) = nil, want whole-load failure")
}
@@ -254,7 +281,7 @@ actions:
// TestLoadMissingDirIsEmptyStore: a nonexistent directory is an empty store
// (no playbooks), matching the flat binding loaders' convention.
func TestLoadMissingDirIsEmptyStore(t *testing.T) {
- store, err := Load(filepath.Join(t.TempDir(), "does-not-exist"))
+ store, err := Load(filepath.Join(t.TempDir(), "does-not-exist"), testSchemas(t))
if err != nil {
t.Fatalf("Load(missing dir) = %v, want nil", err)
}
@@ -276,7 +303,7 @@ actions:
- position: workflow
workflow: tdd
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -301,7 +328,7 @@ actions:
- position: workflow
workflow: tdd
`)
- storeA, err := Load(dir)
+ storeA, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -310,7 +337,7 @@ actions:
}
// Re-load unchanged content: identical version.
- storeB, err := Load(dir)
+ storeB, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -327,7 +354,7 @@ actions:
- position: workflow
workflow: implement
`)
- storeC, err := Load(dir)
+ storeC, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -352,7 +379,7 @@ actions:
- position: workflow
workflow: tdd
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -377,7 +404,7 @@ actions:
// the proof the shipped shape works, not just test fixtures.
func TestShippedExamplePlaybookLoads(t *testing.T) {
dir := filepath.Join("..", "..", "..", "..", "examples", "eda-playbooks")
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load(shipped example): %v", err)
}
@@ -441,7 +468,7 @@ actions:
workflow: tdd
id: notify
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -465,7 +492,7 @@ func TestLoadMalformedActionIDFails(t *testing.T) {
t.Run(id, func(t *testing.T) {
dir := t.TempDir()
writeFile(t, dir, "pb.yaml", "\ntrigger:\n kind: bug\nactions:\n - position: workflow\n workflow: tdd\n id: "+id+"\n")
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatalf("Load(id %q) = nil, want load failure", id)
}
@@ -474,8 +501,7 @@ func TestLoadMalformedActionIDFails(t *testing.T) {
}
// TestValidateActionIDs: the shape/uniqueness helper is the load-boundary's
-// id gate, unit-tested directly because the one-action boundary makes
-// duplicates unreachable through Load today.
+// id gate for both playbook shapes.
func TestValidateActionIDs(t *testing.T) {
if err := validateActionIDs([]rawAction{{ID: "notify"}, {ID: "notify"}}); err == nil {
t.Fatal("validateActionIDs(duplicate) = nil, want error")
@@ -510,7 +536,7 @@ func TestLoadWhenActionsReferenceFails(t *testing.T) {
t.Run(tc.name, func(t *testing.T) {
dir := t.TempDir()
writeFile(t, dir, "pb.yaml", "\ntrigger:\n kind: bug\nactions:\n - position: workflow\n workflow: tdd\n when: "+tc.when+"\n")
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatal("Load = nil, want load failure")
}
@@ -524,29 +550,6 @@ func TestLoadWhenActionsReferenceFails(t *testing.T) {
}
}
-// TestUnknownActionReferenceGeneralRule: the reference check compares the
-// statically-resolved ids against the declared ids of earlier actions, so it
-// already behaves correctly when the one-action boundary later relaxes (the
-// Load path can only exercise the empty-prior set today). The ids are passed
-// directly: under the per-playbook object type an undeclared `actions.`
-// read is rejected at compile time, so there is no longer an env that compiles
-// one to classify.
-func TestUnknownActionReferenceGeneralRule(t *testing.T) {
- // a declared on the prior action: known.
- if id, unknown := unknownActionReference([]rawAction{{ID: "a"}}, 1, []string{"a"}); unknown {
- t.Fatalf("unknownActionReference(declared prior) = (%q, true), want known", id)
- }
- // Two static reads of a in one expression resolve to the one declared id
- // (ActionReferences de-duplicates), so the de-duplicated id is known.
- if id, unknown := unknownActionReference([]rawAction{{ID: "a"}}, 1, []string{"a", "a"}); unknown {
- t.Fatalf("unknownActionReference(deduplicated declared id) = (%q, true), want known", id)
- }
- // A different prior id leaves b unknown.
- if id, unknown := unknownActionReference([]rawAction{{ID: "a"}}, 1, []string{"b"}); !unknown || id != "b" {
- t.Fatalf("unknownActionReference(undeclared) = (%q, %v), want (b, true)", id, unknown)
- }
-}
-
// TestDispatchNilStoreMatchesNothing: a nil store is the state a composition
// root is in before the playbook load runs, and callers hold it through an
// interface where a typed nil is not a nil interface.
@@ -574,7 +577,7 @@ actions:
priority: '3'
label: 'event.label'
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -672,7 +675,7 @@ actions:
t.Run(tc.name, func(t *testing.T) {
dir := t.TempDir()
writeFile(t, dir, "pb.yaml", tc.doc)
- _, err := Load(dir)
+ _, err := Load(dir, testSchemas(t))
if err == nil {
t.Fatal("Load = nil, want load failure")
}
@@ -695,7 +698,7 @@ func TestCompileArgsReportsFirstKeyDeterministically(t *testing.T) {
"a.bad": "event.missing ==",
}
for range 64 {
- _, err := compileArgs("pb.yaml", raw, env, nil)
+ _, err := compileArgs("pb.yaml", "", raw, env, nil)
if err == nil {
t.Fatal("compileArgs = nil, want error")
}
@@ -721,7 +724,7 @@ actions:
args:
label: 'event.missing'
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -742,7 +745,7 @@ actions:
- position: workflow
workflow: tdd
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -769,7 +772,7 @@ actions:
args:
message: '"hello"'
`)
- store, err := Load(dir)
+ store, err := Load(dir, testSchemas(t))
if err != nil {
t.Fatalf("Load: %v", err)
}
@@ -807,3 +810,264 @@ func TestEvalArgsNilStoreSafe(t *testing.T) {
t.Fatalf("EvalArgs(nil store) = %#v, want empty non-nil map", got)
}
}
+
+// TestLoadActionPlaybookReadsPriorResult: a later module action reads an
+// earlier action's declared result by its kind-typed Result field, so the
+// per-action environment (D3) must declare prior ids. This is the first new
+// test that fails if the loader compiled every action against one env instead
+// of an env built from the prior actions' ids.
+func TestLoadActionPlaybookReadsPriorResult(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - id: build
+ position: module
+ kind: log
+ args:
+ message: '"build started"'
+ - id: done
+ position: module
+ kind: log
+ args:
+ message: '"done"'
+ when: actions.build.result.written == true
+`)
+ store, err := Load(dir, testSchemas(t))
+ if err != nil {
+ t.Fatalf("Load(action playbook reading a prior result): %v", err)
+ }
+ pb := store.Playbooks[0]
+ if len(pb.Actions) != 2 {
+ t.Fatalf("loaded %d actions, want 2", len(pb.Actions))
+ }
+ if pb.Actions[1].When == nil {
+ t.Fatal("second action when = nil, want the compiled prior-result read")
+ }
+ if pb.Actions[1].Args["message"] == nil {
+ t.Fatal("second action args[message] = nil, want a compiled program")
+ }
+}
+
+// TestLoadActionPlaybookForwardReferenceFails: an action may not read a later
+// action's id -- the env only declares PRIOR actions' ids, so the forward read
+// is an undefined field at compile.
+func TestLoadActionPlaybookForwardReferenceFails(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - position: module
+ kind: log
+ args:
+ message: '"first"'
+ when: actions.done.result.written == true
+ - id: done
+ position: module
+ kind: log
+ args:
+ message: '"second"'
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(forward reference) = nil, want load failure")
+ }
+ for _, want := range []string{"pb.yaml", "done"} {
+ if !strings.Contains(err.Error(), want) {
+ t.Errorf("Load error = %q, want it to name %q", err.Error(), want)
+ }
+ }
+}
+
+// TestLoadActionPlaybookRejectsUnknownKind: an action's kind must name a
+// registered module kind.
+func TestLoadActionPlaybookRejectsUnknownKind(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - position: module
+ kind: notify
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(unknown kind) = nil, want load failure")
+ }
+ for _, want := range []string{"pb.yaml", "notify"} {
+ if !strings.Contains(err.Error(), want) {
+ t.Errorf("Load error = %q, want it to name %q", err.Error(), want)
+ }
+ }
+}
+
+// TestLoadActionPlaybookRejectsMissingKind: a module action must name a kind.
+func TestLoadActionPlaybookRejectsMissingKind(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - position: module
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(missing kind) = nil, want load failure")
+ }
+ if !strings.Contains(err.Error(), "pb.yaml") {
+ t.Errorf("Load error = %q, want the playbook path named", err.Error())
+ }
+}
+
+// TestLoadActionPlaybookRejectsUnsupportedPosition: a position other than
+// workflow or module is a load failure naming the playbook.
+func TestLoadActionPlaybookRejectsUnsupportedPosition(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - position: channel
+ kind: log
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(channel position) = nil, want load failure")
+ }
+ for _, want := range []string{"pb.yaml", "channel"} {
+ if !strings.Contains(err.Error(), want) {
+ t.Errorf("Load error = %q, want it to name %q", err.Error(), want)
+ }
+ }
+}
+
+// TestLoadActionPlaybookRejectsMixedPositions: workflow and module actions
+// never mix in one playbook (D2).
+func TestLoadActionPlaybookRejectsMixedPositions(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - position: workflow
+ workflow: tdd
+ - position: module
+ kind: log
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(mixed positions) = nil, want load failure")
+ }
+ if !strings.Contains(err.Error(), "pb.yaml") {
+ t.Errorf("Load error = %q, want the playbook path named", err.Error())
+ }
+}
+
+// TestLoadActionPlaybookRejectsZeroActions: a playbook must declare at least
+// one action.
+func TestLoadActionPlaybookRejectsZeroActions(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions: []
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(zero actions) = nil, want load failure")
+ }
+ if !strings.Contains(err.Error(), "pb.yaml") {
+ t.Errorf("Load error = %q, want the playbook path named", err.Error())
+ }
+}
+
+// TestLoadActionPlaybookRejectsDuplicateIDs: duplicate ids are reachable once
+// action playbooks are loadable, and the shared id gate rejects them.
+func TestLoadActionPlaybookRejectsDuplicateIDs(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - id: build
+ position: module
+ kind: log
+ args:
+ message: '"first"'
+ - id: build
+ position: module
+ kind: log
+ args:
+ message: '"second"'
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(duplicate ids) = nil, want load failure")
+ }
+ if !strings.Contains(err.Error(), "duplicate action id") {
+ t.Errorf("Load error = %q, want the duplicate-id rule named", err.Error())
+ }
+}
+
+// TestLoadActionPlaybookRejectsUnknownArgKey: an args key the kind's Args
+// struct does not define fails the load (D4).
+func TestLoadActionPlaybookRejectsUnknownArgKey(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", `
+trigger:
+ kind: bug
+actions:
+ - position: module
+ kind: log
+ args:
+ message: '"hello"'
+ bogus: '"x"'
+`)
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatal("Load(unknown arg key) = nil, want load failure")
+ }
+ for _, want := range []string{"pb.yaml", "bogus"} {
+ if !strings.Contains(err.Error(), want) {
+ t.Errorf("Load error = %q, want it to name %q", err.Error(), want)
+ }
+ }
+}
+
+// TestLoadActionPlaybookRejectsActionReferences is the classifier-enumeration
+// proof (E): every `actions` spelling the old classifier rejected must still
+// be rejected for a typed action playbook. All but the bare `actions` value
+// are rejected by CEL's per-playbook object type at compile; the bare value
+// read is the one spelling CEL does not reject, kept behind the retained
+// resolvable check in expr.ActionReferences.
+func TestLoadActionPlaybookRejectsActionReferences(t *testing.T) {
+ tests := []struct {
+ name string
+ when string
+ }{
+ {name: "unknown id", when: `actions.missing.result.written == true`},
+ {name: "literal map index", when: `actions["build"].result.written == true`},
+ {name: "computed index", when: `actions[key].result.written == true`},
+ {name: "dynamic index by event", when: `actions[event.name].result.written == true`},
+ {name: "in operator", when: `"build" in actions`},
+ {name: "size", when: `size(actions) > 0`},
+ {name: "method call", when: `actions.all(x, true)`},
+ {name: "equality with map", when: `actions == {}`},
+ {name: "bare actions", when: `actions`},
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ dir := t.TempDir()
+ writeFile(t, dir, "pb.yaml", "\ntrigger:\n kind: bug\nactions:\n - id: build\n position: module\n kind: log\n args:\n message: '\"build started\"'\n - id: done\n position: module\n kind: log\n args:\n message: '\"done\"'\n when: "+tc.when+"\n")
+ _, err := Load(dir, testSchemas(t))
+ if err == nil {
+ t.Fatalf("Load(%s) = nil, want load failure", tc.when)
+ }
+ if !strings.Contains(err.Error(), "pb.yaml") {
+ t.Errorf("Load error = %q, want the playbook path named", err.Error())
+ }
+ })
+ }
+}