Files
mesh-delivery/modules/mesh-delivery-sdk/steprun/run_output_test.go
T
jschoubben fad9f059ee BM4b (sdk): an end over the steps state's value is read through the verb answer
A step's end is an event, not a verb's answer, so an end over what the steps
state's value or step-ended carries has a reader of its own: keepOver keeps it
in the steps objects as answer.<ask>, the step key and step-ended carry
answer-object in place of output-object, and the build seats gain the read
verb answer (ask and call, marked chunks); output stays the run text's reader.
Step.Whole and StepEnded.ReadOutput read through answer.

Builds: design 47 H2 §791; H-A-412 (2) and its addendum
2026-11-22 01:08:58 +01:00

130 lines
6.9 KiB
Go

package steprun
import (
"context"
"encoding/json"
"errors"
"strings"
"sync"
"testing"
"time"
sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep"
"git.novox.be/novox/mesh-sdk/go/kvlimit"
)
// Design 47 G A-254, A-290: a build seat's step-ended of a run carries the run's answer, the last line of its program's standard
// output: inline as `output` up to the event bound, else as `answer-object`, the object the holder keeps, which the verb `output`
// answers. The step's key holds the answer only within what the steps state holds per value: over it, a check's whole answer or a
// run's output is the object output.<ask> the key names, kept once; the key and step-ended always say the same outcome, a run
// whose program exited other than 0 failed in both, its answer kept (A-290).
func TestStepEndedOfARunCarriesItsAnswer(t *testing.T) {
big := `"` + strings.Repeat("x", sdkstep.StepEndedInlineMost) + `"`
overKey := `"` + strings.Repeat("y", kvlimit.ModuleStateValueBytes) + `"` // over the steps state, within the event
checkAnswer := map[string]any{"fetch": map[string]any{"workspace": "/w"}, "levels": []any{map[string]any{"level": "unit", "said": strings.Repeat("z", kvlimit.ModuleStateValueBytes)}}}
for _, c := range []struct {
name string
check bool // a check ask answering checkAnswer, not a run
answer sdkstep.RunAnswer
keepErr error
outcome string
inline string
objectKept bool // step-ended names the object
keyObject string // what the object the key names holds: "" none, else the answer's bytes
said string
}{
{name: "a small answer is inline", answer: sdkstep.RunAnswer{Output: json.RawMessage(`{"verdict":true}`)}, outcome: sdkstep.OutcomePassed, inline: `{"verdict":true}`},
{name: "an answer over the event bound is an object", answer: sdkstep.RunAnswer{Output: json.RawMessage(big)}, outcome: sdkstep.OutcomePassed, objectKept: true, keyObject: big},
{name: "an answer over the steps state within the event is inline and the object the key names", answer: sdkstep.RunAnswer{Built: true, Key: "k", Output: json.RawMessage(overKey)},
outcome: sdkstep.OutcomePassed, inline: overKey, keyObject: overKey},
{name: "a program that exits other than 0 failed, its answer kept", answer: sdkstep.RunAnswer{Exit: 3, Output: json.RawMessage(`"no"`), Said: "bad input"},
outcome: sdkstep.OutcomeFailed, inline: `"no"`, said: "the program exited 3: bad input"},
{name: "an answer the holder cannot keep is said", answer: sdkstep.RunAnswer{Output: json.RawMessage(big)}, keepErr: errors.New("store full"),
outcome: sdkstep.OutcomeFailed, said: "store full"},
{name: "a check's answer over the steps state is the object the key names", check: true, outcome: sdkstep.OutcomePassed, keyObject: "check"},
{name: "a check's answer the holder cannot keep fails in its key and its end alike", check: true, keepErr: errors.New("store full"),
outcome: sdkstep.OutcomeFailed, said: "store full"},
} {
t.Run(c.name, func(t *testing.T) {
src, st, sy := NewFakeAsks(), newSteps(), &sayer{}
a := testAsk(sdkstep.AskCheck)
var answer any = c.answer
if c.check {
answer = checkAnswer
} else {
a.Check = nil
in, _ := sdkstep.RunInputOf("seat:mesh-catalog.input", []byte(`{"v":1}`))
commit := "0123456789abcdef0123456789abcdef01234567"
a.Run = &sdkstep.RunJob{Program: sdkstep.RunProgram{Repository: "novox/mesh-delivery", Commit: commit, Dir: "modules/x", Package: "./cmd/x"}, Input: in}
}
_ = src.PublishAsk(a)
var mu sync.Mutex
kept, keeps := map[string][]byte{}, 0
p := &Puller{Source: src, Language: sdkstep.AskGo, Node: "shanks", Put: st.put, Capacity: func() int { return 1 },
PullWait: 10 * time.Millisecond, Heartbeat: time.Hour, Say: sy.say,
KeepAnswer: func(object string, body []byte) error {
mu.Lock()
defer mu.Unlock()
keeps++
if c.keepErr != nil {
return c.keepErr
}
kept[object] = body
return nil
},
Run: func(ctx context.Context, a sdkstep.StepAsk) (any, error) { return answer, nil }}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go p.Pull(ctx)
waitFor(t, "step-ended", func() bool { return len(sy.of("step-ended")) == 1 })
end := sy.of("step-ended")[0].body
if end["outcome"] != c.outcome {
t.Fatalf("outcome %v, want %s (%v)", end["outcome"], c.outcome, end)
}
if c.inline != "" && end["output"] != c.inline {
t.Fatalf("output %.80v, want %.80s inline", end["output"], c.inline)
}
if c.said != "" && !strings.Contains(end["said"].(string), c.said) {
t.Fatalf("said %v, want it to hold %q", end["said"], c.said)
}
key, _ := sdkstep.StepKey("shanks", a.ID)
step, _ := st.get(key)
if raw, err := sdkstep.EncodeStep(step); err != nil || kvlimit.Check("steps", key, len(raw), kvlimit.ModuleStateValueBytes) != nil {
t.Fatalf("the step's key is %d bytes (%v), over what the steps state holds", len(raw), err)
}
if want := map[string]string{sdkstep.OutcomePassed: sdkstep.StepPassed, sdkstep.OutcomeFailed: sdkstep.StepFailed}[c.outcome]; step.State != want {
t.Fatalf("the key ended %s (%s), step-ended %s: no step ends passed in one place and failed in another", step.State, step.Reason, c.outcome)
}
if c.answer.Exit != 0 && (!strings.Contains(step.Reason, c.said) || !strings.Contains(string(step.Result), c.inline)) {
t.Fatalf("the key's reason %q and answer %s, want the exit said and the answer kept", step.Reason, step.Result)
}
mu.Lock()
defer mu.Unlock()
name := sdkstep.AnswerObjectName(a.ID)
if c.objectKept {
if end["answer-object"] != name || end["output"] != nil || string(kept[name]) != big {
t.Fatalf("end %v and kept %d bytes, want the object %s holding the whole answer and no inline output", end["answer-object"], len(kept[name]), name)
}
} else if end["answer-object"] != nil {
t.Fatalf("an object %v was named, want none", end["answer-object"])
}
switch {
case c.keyObject == "":
if step.AnswerObject != "" || (c.keepErr == nil && keeps != 0) {
t.Fatalf("the key names %q and %d objects were kept, want none", step.AnswerObject, keeps)
}
case c.check:
var whole map[string]any
if step.AnswerObject != name || len(step.Result) != 0 || keeps != 1 || json.Unmarshal(kept[name], &whole) != nil || whole["fetch"] == nil {
t.Fatalf("the key names %q with result %.80s, %d keeps; want the object %s holding the whole check answer, kept once", step.AnswerObject, step.Result, keeps, name)
}
default:
var rest sdkstep.RunAnswer
if step.AnswerObject != name || keeps != 1 || string(kept[name]) != c.keyObject || json.Unmarshal(step.Result, &rest) != nil || rest.Output != nil || rest.Key != c.answer.Key {
t.Fatalf("the key names %q with result %.80s, %d keeps; want the object %s holding the output, kept once, and the run answer without it", step.AnswerObject, step.Result, keeps, name)
}
}
})
}
}