88 lines
3.3 KiB
Go
88 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/chain"
|
|
"github.com/novox/mesh-host/validate"
|
|
)
|
|
|
|
// The module of each resource and the build of each module (novox/hq issue 1145, design 47 release 1-2). The
|
|
// composer's owner of an id and the module's build go on the wire only to a machine whose node-engine said it reads
|
|
// them: an older one decodes strictly and refuses a key it does not know, whole.
|
|
|
|
func modulesDeclaration(reads bool) sendable {
|
|
return sendable{
|
|
Resources: []map[string]any{
|
|
{"id": "web.app.conf", "type": "file", "path": "/etc/app.conf", "content": "x\n"},
|
|
{"id": "web.app.data", "type": "file", "path": "/etc/data", "content": "d\n"},
|
|
{"id": "mesh.guard", "type": "file", "path": "/etc/guard", "content": "g\n"}},
|
|
moduleOf: map[string]string{"web.app.conf": "web.app", "web.app.data": "web.app"},
|
|
buildIDs: map[string]string{"web.app": "build-7"},
|
|
ReadsModules: reads,
|
|
}
|
|
}
|
|
|
|
// 1145/AC1
|
|
func TestAMachineThatReadsModulesIsSentEachResourcesModuleAndEachModulesBuild(t *testing.T) {
|
|
keys := bodyKeys(t, modulesDeclaration(true))
|
|
builds, _ := keys["builds"].(map[string]any)
|
|
if len(builds) != 1 || builds["web.app"] != "build-7" {
|
|
t.Fatalf("1145/AC1: the body carries builds %v", keys["builds"])
|
|
}
|
|
want := map[string]any{"web.app.conf": "web.app", "web.app.data": "web.app", "mesh.guard": nil}
|
|
for _, r := range keys["resources"].([]any) {
|
|
r := r.(map[string]any)
|
|
if r["module"] != want[r["id"].(string)] {
|
|
t.Errorf("1145/AC1: resource %v carries module %v, want %v", r["id"], r["module"], want[r["id"].(string)])
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1145/AC2: the body is byte for byte what it is today.
|
|
func TestAMachineThatDoesNotReadModulesIsSentTheBodyItWasSentBefore(t *testing.T) {
|
|
d := modulesDeclaration(false)
|
|
got, err := d.Body()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before := sendable{Resources: d.Resources}
|
|
want, _ := before.Body()
|
|
if string(got) != string(want) {
|
|
t.Fatalf("1145/AC2: the body changed:\n%s\nwas\n%s", got, want)
|
|
}
|
|
}
|
|
|
|
// 1145/AC4: the node-engine's own validator, as the gate runs it, takes the two words.
|
|
func TestTheNodeEnginesValidatorTakesAModulePerResourceAndABuildPerModule(t *testing.T) {
|
|
raw, err := modulesDeclaration(true).Body()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var generic map[string]any
|
|
if err := json.Unmarshal(raw, &generic); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if problems := validate.Declaration(raw); len(problems) != 0 {
|
|
t.Fatalf("1145/AC4: refused: %q\n%s", problems, fmt.Sprint(generic))
|
|
}
|
|
}
|
|
|
|
// The build a module carries is the one its assignment names when that is the commit carried, else the one built from
|
|
// the commit carried; none when neither is known.
|
|
func TestTheBuildOfACarriedCommitIsTheAssignmentsOrTheOneBuiltFromIt(t *testing.T) {
|
|
runs := map[string]chain.Ref{"a": {Build: "b-a", Commit: "c1"}, "b": {Build: "b-old", Commit: "c0"}}
|
|
looked := map[string]string{"b/c2": "b-new"}
|
|
got, err := wireBuilds(map[string]string{"a": "c1", "b": "c2", "c": "c3", "d": ""}, runs,
|
|
func(module, commit string) (string, error) { return looked[module+"/"+commit], nil })
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := map[string]string{"a": "b-a", "b": "b-new"}
|
|
if len(got) != len(want) || got["a"] != want["a"] || got["b"] != want["b"] {
|
|
t.Fatalf("1145: builds %v, want %v", got, want)
|
|
}
|
|
}
|