diff --git a/next/genesis/activity-types/define_trigger.sx b/next/genesis/activity-types/define_trigger.sx new file mode 100644 index 00000000..31a60423 --- /dev/null +++ b/next/genesis/activity-types/define_trigger.sx @@ -0,0 +1,33 @@ +;; next/genesis/activity-types/define_trigger.sx +;; +;; Bootstrap definition of the DefineTrigger verb per +;; plans/agent-briefings/fed-sx-triggers-loop.md (Phase 1) and +;; plans/fed-sx-design.md §13. Read as data by the bundler +;; (bootstrap.erl) — never evaluated as code. +;; +;; DefineTrigger binds an activity-type to a flow. When a matching +;; activity is appended to the log, the kernel's trigger fan-out +;; (pipeline.erl, post-append) looks the type up in the trigger +;; registry and starts the named flow with the activity as input. +;; The activity's :object is the binding record: +;; {:activity-type "Create" ;; the verb to fire on +;; :flow-name "blog-publish-digest" +;; :guard ;; discriminator +;; :actor-scope } ;; default: any +;; +;; The schema validates the *activity* shape: :object present with +;; string :activity-type and :flow-name. The optional :guard lets one +;; type bind to multiple flows with discriminators; it is resolved to +;; an Erlang predicate at registration time (trigger_registry), not +;; carried in the pure-predicate schema here. Schema bodies use nested +;; `get` (not keyword-threading) so the predicate is evaluatable. +(DefineActivity + :name "DefineTrigger" + :doc "Bind an activity-type to a flow. :object carries :activity-type, :flow-name, and optional :guard and :actor-scope." + :schema (fn + (act) + (and + (not (nil? (get act :object))) + (string? (get (get act :object) :activity-type)) + (string? (get (get act :object) :flow-name)))) + :semantics (fn (state act) state)) diff --git a/next/genesis/manifest.sx b/next/genesis/manifest.sx index 7e111720..5ba90afb 100644 --- a/next/genesis/manifest.sx +++ b/next/genesis/manifest.sx @@ -24,7 +24,8 @@ "activity-types/announce.sx" "activity-types/endorse.sx" "activity-types/define_type.sx" - "activity-types/subtype_of.sx") + "activity-types/subtype_of.sx" + "activity-types/define_trigger.sx") :object-types ("object-types/sx-artifact.sx" "object-types/note.sx" "object-types/tombstone.sx" diff --git a/next/kernel/trigger_registry.erl b/next/kernel/trigger_registry.erl new file mode 100644 index 00000000..bdec3b4e --- /dev/null +++ b/next/kernel/trigger_registry.erl @@ -0,0 +1,180 @@ +-module(trigger_registry). +-export([new/0, add/3, remove/2, lookup/2, all/1, fold/2, fold_fn/0, + mk_spec/4, spec_cid/1, spec_flow_name/1, spec_guard/1, + spec_actor_scope/1, + start_link/0, start_link/1, stop/0, + add/2, remove/1, lookup/1, all_triggers/0]). +-export([init/1, handle_call/3, handle_cast/2, handle_info/2]). +-behaviour(gen_server). + +%% Trigger registry — binds activity-types to durable flows +%% (plans/agent-briefings/fed-sx-triggers-loop.md, Phase 1). When an +%% activity is appended, the kernel's post-append fan-out +%% (pipeline.erl, Phase 2) looks the activity's type up here and starts +%% each registered flow. Mirrors the peer_actors / peer_types shape: a +%% pure-functional core plus a registered gen_server, hydrated on start +%% from a fold over DefineTrigger activities. +%% +%% State shape (pure-functional): +%% [{ActivityType, [Spec, ...]}, ...] +%% Multiple triggers may bind the same activity-type; they fire +%% independently. A Spec is a 4-tuple: +%% {TriggerCid, FlowName, Guard, ActorScope} +%% TriggerCid — content-address of the DefineTrigger activity +%% (dedup + audit); `undefined` if not yet addressed. +%% FlowName — the flow_store-registered flow to start. +%% Guard — fun ((Activity, ActorState) -> bool) | undefined. +%% Lets one type bind multiple flows with +%% discriminators ("only Articles in :newsletter"). +%% Resolved to a fun at registration; not carried over +%% the wire (term_codec can't encode funs). +%% ActorScope — an actor id the trigger is scoped to, or `any`. + +%% ── Spec constructor / accessors ──────────────────────────────── + +mk_spec(TriggerCid, FlowName, Guard, ActorScope) -> + {TriggerCid, FlowName, Guard, ActorScope}. + +spec_cid({Cid, _, _, _}) -> Cid. +spec_flow_name({_, FlowName, _, _}) -> FlowName. +spec_guard({_, _, Guard, _}) -> Guard. +spec_actor_scope({_, _, _, Scope}) -> Scope. + +%% ── Pure-functional API ───────────────────────────────────────── + +new() -> []. + +%% add(ActivityType, Spec, State) — append Spec to ActivityType's list. +add(ActivityType, Spec, State) -> + Existing = lookup(ActivityType, State), + set_keyed(ActivityType, append1(Existing, Spec), State). + +%% remove(TriggerCid, State) — drop every spec carrying TriggerCid, +%% across all activity-types; empties are pruned. +remove(TriggerCid, State) -> + prune([{T, drop_cid(TriggerCid, Specs)} || {T, Specs} <- State]). + +%% lookup(ActivityType, State) — the specs bound to ActivityType ([] if +%% none). +lookup(ActivityType, State) -> + case find_keyed(ActivityType, State) of + {ok, Specs} -> Specs; + not_found -> [] + end. + +all(State) -> State. + +%% ── Hydration fold ────────────────────────────────────────────── +%% +%% fold(Activity, State) — register the binding carried by a +%% DefineTrigger activity. Replaying the actor log through this fold +%% rebuilds the registry after a restart (same content-addressing +%% discipline as define_registry). A non-DefineTrigger activity passes +%% through untouched. + +fold(Activity, State) -> + case envelope:get_field(type, Activity) of + {ok, define_trigger} -> fold_trigger(Activity, State); + _ -> State + end. + +fold_trigger(Activity, State) -> + case envelope:get_field(object, Activity) of + {ok, Obj} -> + case binding_of(Activity, Obj) of + {ok, AType, Spec} -> add(AType, Spec, State); + not_a_binding -> State + end; + _ -> State + end. + +binding_of(Activity, Obj) -> + case envelope:get_field(activity_type, Obj) of + {ok, AType} -> + case envelope:get_field(flow_name, Obj) of + {ok, FlowName} -> + Guard = field_or(guard, Obj, undefined), + Scope = field_or(actor_scope, Obj, any), + Cid = field_or(id, Activity, undefined), + {ok, AType, mk_spec(Cid, FlowName, Guard, Scope)}; + _ -> not_a_binding + end; + _ -> not_a_binding + end. + +%% fold_fn/0 — a 2-arity fun the projection scheduler can plant. +fold_fn() -> + fun (Activity, State) -> fold(Activity, State) end. + +%% ── gen_server wrapper ────────────────────────────────────────── + +start_link() -> + start_link([]). + +start_link(InitialState) -> + Pid = gen_server:start_link(trigger_registry, [InitialState]), + erlang:register(trigger_registry, Pid), + Pid. + +stop() -> + R = gen_server:call(trigger_registry, '$gen_stop'), + erlang:unregister(trigger_registry), + R. + +add(ActivityType, Spec) -> + gen_server:call(trigger_registry, {add, ActivityType, Spec}). + +remove(TriggerCid) -> + gen_server:call(trigger_registry, {remove, TriggerCid}). + +lookup(ActivityType) -> + gen_server:call(trigger_registry, {lookup, ActivityType}). + +all_triggers() -> + gen_server:call(trigger_registry, all_triggers). + +init([InitialState]) -> + {ok, InitialState}. + +handle_call({add, ActivityType, Spec}, _From, State) -> + {reply, ok, add(ActivityType, Spec, State)}; +handle_call({remove, TriggerCid}, _From, State) -> + {reply, ok, remove(TriggerCid, State)}; +handle_call({lookup, ActivityType}, _From, State) -> + {reply, lookup(ActivityType, State), State}; +handle_call(all_triggers, _From, State) -> + {reply, State, State}. + +handle_cast(_, S) -> {noreply, S}. + +handle_info(_, S) -> {noreply, S}. + +%% ── helpers ───────────────────────────────────────────────────── + +field_or(Key, Proplist, Default) -> + case envelope:get_field(Key, Proplist) of + {ok, V} -> V; + _ -> Default + end. + +drop_cid(_, []) -> []; +drop_cid(Cid, [Spec | Rest]) -> + case spec_cid(Spec) of + Cid -> drop_cid(Cid, Rest); + _ -> [Spec | drop_cid(Cid, Rest)] + end. + +prune([]) -> []; +prune([{_, []} | Rest]) -> prune(Rest); +prune([P | Rest]) -> [P | prune(Rest)]. + +append1([], X) -> [X]; +append1([H | T], X) -> [H | append1(T, X)]. + +find_keyed(_, []) -> not_found; +find_keyed(K, [{K, V} | _]) -> {ok, V}; +find_keyed(K, [_ | Rest]) -> find_keyed(K, Rest). + +set_keyed(K, V, []) -> [{K, V}]; +set_keyed(K, V, [{K, _} | Rest]) -> [{K, V} | Rest]; +set_keyed(K, V, [P | Rest]) -> [P | set_keyed(K, V, Rest)]. diff --git a/next/tests/bootstrap_load.sh b/next/tests/bootstrap_load.sh index a052f944..ce15f735 100755 --- a/next/tests/bootstrap_load.sh +++ b/next/tests/bootstrap_load.sh @@ -79,7 +79,7 @@ cat > "$TMPFILE" <<'EPOCHS' (eval "(get (erlang-eval-ast \"R = bootstrap:read_genesis(), {ok, S1} = bootstrap:load_genesis(R), {ok, S2} = bootstrap:load_genesis(R), cid:to_string(S1) =:= cid:to_string(S2)\") :name)") EPOCHS -OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMPFILE" 2>/dev/null) +OUTPUT=$(timeout 590 "$SX_SERVER" < "$TMPFILE" 2>/dev/null) check() { local epoch="$1" desc="$2" expected="$3" @@ -106,7 +106,7 @@ check 10 "strip suffix create.sx -> create" "true" check 11 "strip suffix hello unchanged" "true" check 12 "strip suffix .sx -> empty" "true" check 13 "load_genesis rejects bad shape" "ok" -check 20 "loaded activity_types count = 7" "7" +check 20 "loaded activity_types count = 8" "8" check 21 "loaded object_types count = 13" "13" check 22 "loaded projections count = 7" "7" check 23 "loaded validators count = 3" "3" diff --git a/next/tests/bootstrap_populate.sh b/next/tests/bootstrap_populate.sh index 41707f0d..18780a6c 100755 --- a/next/tests/bootstrap_populate.sh +++ b/next/tests/bootstrap_populate.sh @@ -99,8 +99,8 @@ check() { check 2 "gen_server loaded" "gen_server" check 3 "registry loaded" "registry" check 4 "bootstrap loaded" "bootstrap" -check 10 "populate returns total 38" "38" -check 20 "activity_types count = 7" "7" +check 10 "populate returns total 39" "39" +check 20 "activity_types count = 8" "8" check 21 "object_types count = 13" "13" check 22 "projections count = 7" "7" check 23 "validators count = 3" "3" diff --git a/next/tests/bootstrap_read.sh b/next/tests/bootstrap_read.sh index 20703651..2e9d2667 100755 --- a/next/tests/bootstrap_read.sh +++ b/next/tests/bootstrap_read.sh @@ -102,7 +102,7 @@ check 10 "sections/0 length" "7" check 11 "ends_with_sx create.sx" "true" check 12 "ends_with_sx hello" "false" check 13 "ends_with_sx empty" "false" -check 20 "section activity_types count" "7" +check 20 "section activity_types count" "8" check 21 "section object_types count" "13" check 22 "section projections count" "7" check 23 "section validators count" "3" @@ -111,7 +111,7 @@ check 25 "section sig_suites count" "2" check 26 "section audience count" "3" check 30 "read_genesis returns 7 sections" "7" check 31 "first section name" "activity_types" -check 32 "first section entry count" "7" +check 32 "first section entry count" "8" TOTAL=$((PASS+FAIL)) if [ $FAIL -eq 0 ]; then diff --git a/next/tests/bootstrap_start.sh b/next/tests/bootstrap_start.sh index 50523a15..aa7b5243 100755 --- a/next/tests/bootstrap_start.sh +++ b/next/tests/bootstrap_start.sh @@ -121,10 +121,10 @@ check() { check 10 "bootstrap module loaded" "bootstrap" check 20 "whereis(nx_kernel) is Pid" "true" -check 21 "activity_types count = 7" "7" +check 21 "activity_types count = 8" "8" check 22 "object_types count = 13" "13" check 23 "projections count = 7" "7" -check 24 "total entries = 38" "38" +check 24 "total entries = 39" "39" check 25 "fresh log_tip = 0" "0" check 26 "publish advances tip to 1" "1" check 27 "actor_id = alice" "true" diff --git a/next/tests/define_trigger.sh b/next/tests/define_trigger.sh new file mode 100755 index 00000000..565e3832 --- /dev/null +++ b/next/tests/define_trigger.sh @@ -0,0 +1,99 @@ +#!/usr/bin/env bash +# next/tests/define_trigger.sh — fed-sx triggers Phase 1 (verb). +# +# The DefineTrigger genesis verb +# (next/genesis/activity-types/define_trigger.sx) binds an activity-type +# to a flow. This suite confirms it parses with the expected +# DefineActivity head + :name, that its :schema accepts a well-formed +# binding and rejects malformed ones, and that a DefineTrigger envelope +# round-trips through term_codec. + +set -uo pipefail +cd "$(git rev-parse --show-toplevel)" + +SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}" +if [ ! -x "$SX_SERVER" ]; then + SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe" +fi +if [ ! -x "$SX_SERVER" ]; then + echo "ERROR: sx_server.exe not found." >&2 + exit 1 +fi + +VERBOSE="${1:-}" +PASS=0; FAIL=0; ERRORS="" +TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT + +SCH='(eval-expr (get (apply dict (rest (parse (file-read \"next/genesis/activity-types/define_trigger.sx\")))) :schema))' + +cat > "$TMPFILE" < true +(epoch 20) +(eval "(define sch ${SCH}) (sch (dict :object (dict :activity-type \"Create\" :flow-name \"blog-publish-digest\")))") +;; reject: missing :activity-type -> false +(epoch 21) +(eval "(define sch ${SCH}) (sch (dict :object (dict :flow-name \"f\")))") +;; reject: missing :flow-name -> false +(epoch 22) +(eval "(define sch ${SCH}) (sch (dict :object (dict :activity-type \"Create\")))") + +;; ── envelope round-trip through term_codec ───────────────── +(epoch 30) +(eval "(get (erlang-eval-ast \"A = [{type, define_trigger}, {actor, alice}, {object, [{activity_type, create}, {flow_name, blog_publish_digest}]}], {ok, D, _} = term_codec:decode(term_codec:encode(A)), D =:= A\") :name)") +EPOCHS + +OUTPUT=$(timeout 180 "$SX_SERVER" < "$TMPFILE" 2>/dev/null) + +check() { + local epoch="$1" desc="$2" expected="$3" + local actual + actual=$(echo "$OUTPUT" | awk -v e="$epoch" ' + $0 ~ "^\\(ok-len " e " " { getline; print; exit } + $0 ~ "^\\(ok " e " " { print; exit } + $0 ~ "^\\(error " e " " { print; exit } + ') + [ -z "$actual" ] && actual="" + if echo "$actual" | grep -qF -- "$expected"; then + PASS=$((PASS+1)) + [ "$VERBOSE" = "-v" ] && echo " ok $desc" + else + FAIL=$((FAIL+1)) + ERRORS+=" FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual +" + fi +} + +check 10 "define_trigger.sx head form" "DefineActivity" +check 11 "define_trigger.sx name" "DefineTrigger" +check 20 "schema accepts valid binding" "true" +check 21 "schema rejects missing type" "false" +check 22 "schema rejects missing flow-name" "false" +check 30 "DefineTrigger envelope round-trips" "true" + +TOTAL=$((PASS+FAIL)) +if [ $FAIL -eq 0 ]; then + echo "ok $PASS/$TOTAL next/tests/define_trigger.sh passed" +else + echo "FAIL $PASS/$TOTAL passed, $FAIL failed:" + echo "$ERRORS" +fi +[ $FAIL -eq 0 ] diff --git a/next/tests/genesis_parse.sh b/next/tests/genesis_parse.sh index a8f2bc93..09b8060e 100755 --- a/next/tests/genesis_parse.sh +++ b/next/tests/genesis_parse.sh @@ -56,6 +56,10 @@ cat > "$TMPFILE" <<'EPOCHS' (eval "(first (parse (file-read \"next/genesis/activity-types/subtype_of.sx\")))") (epoch 204) (eval "(get (apply dict (rest (parse (file-read \"next/genesis/activity-types/subtype_of.sx\")))) :name)") +(epoch 205) +(eval "(first (parse (file-read \"next/genesis/activity-types/define_trigger.sx\")))") +(epoch 206) +(eval "(get (apply dict (rest (parse (file-read \"next/genesis/activity-types/define_trigger.sx\")))) :name)") (epoch 19) (eval "(len (get (apply dict (rest (parse (file-read \"next/genesis/manifest.sx\")))) :activity-types))") (epoch 30) @@ -192,7 +196,9 @@ check 201 "define_type.sx head form" "DefineActivity" check 202 "define_type.sx name" "DefineType" check 203 "subtype_of.sx head form" "DefineActivity" check 204 "subtype_of.sx name" "SubtypeOf" -check 19 "manifest has 7 activity-types" "7" +check 205 "define_trigger.sx head form" "DefineActivity" +check 206 "define_trigger.sx name" "DefineTrigger" +check 19 "manifest has 8 activity-types" "8" check 30 "sx-artifact.sx head form" "DefineObject" check 31 "sx-artifact.sx name" "SXArtifact" check 32 "note.sx name" "Note" diff --git a/next/tests/trigger_registry.sh b/next/tests/trigger_registry.sh new file mode 100755 index 00000000..ffe13067 --- /dev/null +++ b/next/tests/trigger_registry.sh @@ -0,0 +1,143 @@ +#!/usr/bin/env bash +# next/tests/trigger_registry.sh — fed-sx triggers Phase 1 (registry). +# +# trigger_registry binds activity-types to durable flows. The kernel's +# post-append fan-out (Phase 2) looks an arriving activity's type up +# here and starts each registered flow. Mirrors peer_actors / peer_types: +# a pure core + a gen_server, hydrated from a fold over DefineTrigger +# activities. + +set -uo pipefail +cd "$(git rev-parse --show-toplevel)" + +SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}" +if [ ! -x "$SX_SERVER" ]; then + SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe" +fi +if [ ! -x "$SX_SERVER" ]; then + echo "ERROR: sx_server.exe not found." >&2 + exit 1 +fi + +VERBOSE="${1:-}" +PASS=0; FAIL=0; ERRORS="" +TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT + +# Spec1/Spec2 bind activity-type `create`. TrigAct/TrigAct2 are +# DefineTrigger activities the fold hydrates from. +SETUP='S1 = trigger_registry:mk_spec(<<99,49>>, flow_a, undefined, any), S2 = trigger_registry:mk_spec(<<99,50>>, flow_b, undefined, any), TrigAct = [{type, define_trigger}, {actor, alice}, {id, <<99,49>>}, {object, [{activity_type, create}, {flow_name, flow_a}]}], TrigAct2 = [{type, define_trigger}, {actor, alice}, {id, <<99,50>>}, {object, [{activity_type, follow}, {flow_name, flow_c}]}], Note = [{type, note}, {actor, alice}, {object, [{content, hi}]}],' + +cat > "$TMPFILE" < [] +(epoch 12) +(eval "(get (erlang-eval-ast \"${SETUP} trigger_registry:lookup(create, trigger_registry:new()) =:= []\") :name)") +;; multi-bind: two specs on the same activity-type, both returned in order +(epoch 13) +(eval "(get (erlang-eval-ast \"${SETUP} St = trigger_registry:add(create, S2, trigger_registry:add(create, S1, trigger_registry:new())), trigger_registry:lookup(create, St) =:= [S1, S2]\") :name)") +;; remove by trigger cid +(epoch 14) +(eval "(get (erlang-eval-ast \"${SETUP} St = trigger_registry:add(create, S2, trigger_registry:add(create, S1, trigger_registry:new())), trigger_registry:lookup(create, trigger_registry:remove(<<99,49>>, St)) =:= [S2]\") :name)") +;; remove last spec for a type prunes the type +(epoch 15) +(eval "(get (erlang-eval-ast \"${SETUP} St = trigger_registry:add(create, S1, trigger_registry:new()), trigger_registry:remove(<<99,49>>, St) =:= []\") :name)") +;; spec accessors +(epoch 16) +(eval "(get (erlang-eval-ast \"${SETUP} {trigger_registry:spec_cid(S1), trigger_registry:spec_flow_name(S1), trigger_registry:spec_guard(S1), trigger_registry:spec_actor_scope(S1)} =:= {<<99,49>>, flow_a, undefined, any}\") :name)") + +;; ── hydration fold ───────────────────────────────────────── +;; a DefineTrigger activity registers its binding +(epoch 20) +(eval "(get (erlang-eval-ast \"${SETUP} St = trigger_registry:fold(TrigAct, trigger_registry:new()), trigger_registry:lookup(create, St) =:= [trigger_registry:mk_spec(<<99,49>>, flow_a, undefined, any)]\") :name)") +;; a non-trigger activity passes through untouched +(epoch 21) +(eval "(get (erlang-eval-ast \"${SETUP} trigger_registry:fold(Note, trigger_registry:new()) =:= []\") :name)") +;; folding several Trigger activities rebuilds the whole registry +(epoch 22) +(eval "(get (erlang-eval-ast \"${SETUP} St = trigger_registry:fold(TrigAct2, trigger_registry:fold(TrigAct, trigger_registry:new())), {trigger_registry:lookup(create, St), trigger_registry:lookup(follow, St)} =:= {[trigger_registry:mk_spec(<<99,49>>, flow_a, undefined, any)], [trigger_registry:mk_spec(<<99,50>>, flow_c, undefined, any)]}\") :name)") +;; fold_fn/0 is a 2-arity fun +(epoch 23) +(eval "(get (erlang-eval-ast \"is_function(trigger_registry:fold_fn(), 2)\") :name)") + +;; ── gen_server ───────────────────────────────────────────── +(epoch 30) +(eval "(get (erlang-eval-ast \"${SETUP} trigger_registry:start_link(), trigger_registry:add(create, S1), trigger_registry:lookup(create) =:= [S1]\") :name)") +(epoch 31) +(eval "(get (erlang-eval-ast \"trigger_registry:start_link(), trigger_registry:lookup(create) =:= []\") :name)") +(epoch 32) +(eval "(get (erlang-eval-ast \"${SETUP} trigger_registry:start_link(), trigger_registry:add(create, S1), trigger_registry:add(create, S2), trigger_registry:remove(<<99,49>>), trigger_registry:lookup(create) =:= [S2]\") :name)") +(epoch 33) +(eval "(get (erlang-eval-ast \"${SETUP} trigger_registry:start_link(), trigger_registry:add(create, S1), trigger_registry:add(follow, S2), trigger_registry:all_triggers() =:= [{create, [S1]}, {follow, [S2]}]\") :name)") +;; start_link/1 pre-populates from a hydrated state +(epoch 34) +(eval "(get (erlang-eval-ast \"${SETUP} St = trigger_registry:fold(TrigAct, trigger_registry:new()), trigger_registry:start_link(St), trigger_registry:lookup(create) =:= [trigger_registry:mk_spec(<<99,49>>, flow_a, undefined, any)]\") :name)") +EPOCHS + +OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMPFILE" 2>/dev/null) + +check() { + local epoch="$1" desc="$2" expected="$3" + local actual + actual=$(echo "$OUTPUT" | awk -v e="$epoch" ' + $0 ~ "^\\(ok-len " e " " { getline; print; exit } + $0 ~ "^\\(ok " e " " { print; exit } + $0 ~ "^\\(error " e " " { print; exit } + ') + [ -z "$actual" ] && actual="" + if echo "$actual" | grep -qF -- "$expected"; then + PASS=$((PASS+1)) + [ "$VERBOSE" = "-v" ] && echo " ok $desc" + else + FAIL=$((FAIL+1)) + ERRORS+=" FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual +" + fi +} + +check 4 "trigger_registry module loaded" "trigger_registry" +check 10 "new/0 -> []" "true" +check 11 "add + lookup round-trip" "true" +check 12 "lookup no match -> []" "true" +check 13 "multi-bind same type, ordered" "true" +check 14 "remove by trigger cid" "true" +check 15 "remove last prunes the type" "true" +check 16 "spec accessors" "true" +check 20 "fold registers a binding" "true" +check 21 "fold non-trigger passes through" "true" +check 22 "fold hydration rebuilds registry" "true" +check 23 "fold_fn/0 is fun/2" "true" +check 30 "gen_server add + lookup" "true" +check 31 "gen_server lookup no match -> []" "true" +check 32 "gen_server remove" "true" +check 33 "gen_server all_triggers" "true" +check 34 "start_link/1 pre-populates" "true" + +TOTAL=$((PASS+FAIL)) +if [ $FAIL -eq 0 ]; then + echo "ok $PASS/$TOTAL next/tests/trigger_registry.sh passed" +else + echo "FAIL $PASS/$TOTAL passed, $FAIL failed:" + echo "$ERRORS" +fi +[ $FAIL -eq 0 ]