96 lines
2.8 KiB
Go
96 lines
2.8 KiB
Go
package build
|
|
|
|
// The fakes of the build modules the builder tests run against: a caller answering a long tool at once with the step and its key,
|
|
// and the steps watch. The caller, the steps watch and the runner themselves are the SDK's (mesh-sdk go/delivery/buildrun, issue 1671).
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshwatchdogs"
|
|
"git.novox.be/novox/mesh-delivery/sdk/buildstep"
|
|
)
|
|
|
|
type call struct {
|
|
node, key string
|
|
body any
|
|
}
|
|
|
|
// fakeCaller answers a long tool as the build modules do: at once, with the step and its key.
|
|
type fakeCaller struct {
|
|
calls []call
|
|
answer string
|
|
err error
|
|
}
|
|
|
|
func (f *fakeCaller) CallOn(node, key string, body any) (json.RawMessage, error) {
|
|
f.calls = append(f.calls, call{node, key, body})
|
|
if f.err != nil {
|
|
return nil, f.err
|
|
}
|
|
return json.RawMessage(f.answer), nil
|
|
}
|
|
|
|
// fakeSteps holds the steps values by `<module>/<key>`; Wait on a key it does not hold blocks until the context ends.
|
|
type fakeSteps struct {
|
|
mu sync.Mutex
|
|
steps map[string]buildstep.Step
|
|
// during, when set, is called as a wait starts and the function it answers as the wait ends.
|
|
during func(key string) func()
|
|
}
|
|
|
|
func (f *fakeSteps) Wait(ctx context.Context, module, key string) (buildstep.Step, error) {
|
|
f.mu.Lock()
|
|
s, ok := f.steps[module+"/"+key]
|
|
during := f.during
|
|
f.mu.Unlock()
|
|
if ok {
|
|
if during != nil {
|
|
defer during(key)()
|
|
}
|
|
return s, nil
|
|
}
|
|
<-ctx.Done()
|
|
return buildstep.Step{}, context.Cause(ctx)
|
|
}
|
|
|
|
func stepAt(node, id, state, reason string, result string) buildstep.Step {
|
|
s := buildstep.Step{ID: id, Tool: "build_go_fetch", Node: node, State: state, Reason: reason}
|
|
if result != "" {
|
|
s.Result = json.RawMessage(result)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// presenceValue is a watchman presence value, as its writer encodes it (mesh-sdk go/delivery EncodePresence).
|
|
func presenceValue(t *testing.T, online bool) []byte {
|
|
t.Helper()
|
|
b, err := json.Marshal(meshwatchdogs.PresenceByNodeValue{Online: online})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
// tcValue is a toolchains value, as the build module's writer encodes it (mesh-sdk go/delivery EncodeToolchain).
|
|
func tcValue(t *testing.T, language, version string) []byte {
|
|
t.Helper()
|
|
b, err := buildstep.EncodeToolchain(buildstep.Toolchain{Language: language, Version: version, Recipe: "1", At: time.Now().UTC()})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return b
|
|
}
|
|
|
|
// tcs are the toolchain entries of a language on nodes, as the toolchains set gives them.
|
|
func tcs(language, version string, nodes ...string) []buildstep.NodeToolchain {
|
|
var out []buildstep.NodeToolchain
|
|
for _, n := range nodes {
|
|
out = append(out, buildstep.NodeToolchain{Node: n, Toolchain: buildstep.Toolchain{Language: language, Version: version, Recipe: "1"}})
|
|
}
|
|
return out
|
|
}
|