220 lines
11 KiB
Go
220 lines
11 KiB
Go
package composer
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
"github.com/novox/mesh-host/internal/compose"
|
|
"github.com/novox/mesh-host/internal/compose/frombus"
|
|
"github.com/novox/mesh-host/internal/compose/frombus/frombustest"
|
|
)
|
|
|
|
const demo = `{"module": "demo", "version": "1", "claims": [{"name": "node-files"}]}`
|
|
|
|
// withInput is r with in as its input, as a caller puts it on the wire: the request's shape carries the input as JSON.
|
|
func withInput(t *testing.T, r Request, in compose.Input) Request {
|
|
t.Helper()
|
|
raw, err := json.Marshal(in)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal(raw, &r.Input); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return r
|
|
}
|
|
|
|
// The seats a node's assigned modules claim are held there when the request says the holdings come from the claims.
|
|
func TestHoldingsComeFromTheClaims(t *testing.T) {
|
|
m, err := catalogue.Decode([]byte(demo))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := HoldingsOf(map[string]catalogue.Manifest{"demo": m}, []compose.Node{{Name: "b", Assigned: []string{"demo"}}, {Name: "a", Assigned: []string{"demo"}}})
|
|
if len(got) != 2 || got[0].Node != "a" || got[0].Claim != "node-files" || got[0].Scope != "node" {
|
|
t.Fatalf("holdings = %+v", got)
|
|
}
|
|
}
|
|
|
|
// A request the command cannot run is refused, never answered as a verdict: a case named twice, an unknown depth.
|
|
func TestARequestItCannotRunIsRefused(t *testing.T) {
|
|
if _, err := Run(Request{V: Version, Cases: []Case{{Name: "a"}, {Name: "a"}}}); err == nil {
|
|
t.Error("a case named twice runs")
|
|
}
|
|
if _, err := Run(Request{V: Version, Depth: "deep"}); err == nil {
|
|
t.Error("an unknown depth runs")
|
|
}
|
|
// A case's own placement (issue 1126) composes over a node the input holds, and is refused for one it does not.
|
|
placed := withInput(t, Request{V: Version, Machines: []string{"a"}, Depth: DepthResolve,
|
|
Cases: []Case{{Name: "trunk", Manifests: map[string]Manifest{"demo": {Raw: json.RawMessage(demo)}}},
|
|
{Name: "change", Manifests: map[string]Manifest{"demo": {Raw: json.RawMessage(demo)}},
|
|
Placements: map[string]*delivery.Placement{"a": {Node: "a", Modules: []delivery.PlacedModule{{Module: "ghost"}}}}}}},
|
|
compose.Input{Nodes: []compose.Node{{Name: "a"}}})
|
|
if v, err := Run(placed); err != nil || !v.Cases[0].Machines["a"].Composes || v.Cases[1].Machines["a"].Composes ||
|
|
!strings.Contains(v.Cases[1].Machines["a"].Reason, "ghost") {
|
|
t.Errorf("a case composes its own placement: %+v, %v", v, err)
|
|
}
|
|
placed.Cases[1].Placements = map[string]*delivery.Placement{"z": {Node: "z"}}
|
|
if _, err := Run(placed); err == nil || !strings.Contains(err.Error(), "holds no node for") {
|
|
t.Errorf("a case placing a node the input lacks: %v", err)
|
|
}
|
|
// Issue 1126 (check of mesh-host #200): the module the mesh provides itself (the private network) comes from mesh-sdk,
|
|
// a second source beside the indexer's manifests the cases carry, and the input carries no catalogue: a node it is
|
|
// assigned to still composes, and what it provides is provided.
|
|
wg := delivery.ProvidedModules()[0]
|
|
provided := withInput(t, Request{V: Version, Machines: []string{"a"}, Depth: DepthResolve,
|
|
Cases: []Case{{Name: "change", Manifests: map[string]Manifest{"demo": {Raw: json.RawMessage(demo)}}}}},
|
|
compose.Input{Nodes: []compose.Node{{Name: "a", Assigned: []string{wg, "demo"}}}})
|
|
if v, err := Run(provided); err != nil || !v.Cases[0].Machines["a"].Composes {
|
|
t.Errorf("a node assigned the mesh's own module: %+v, %v", v, err)
|
|
}
|
|
// Issue 1126 (checks of mesh-host #200, fix-a-bug-met-twice): the sandbox composes one node from the same inputs as
|
|
// the bus reader, through one path. A mesh whose restic is built (its files from an archive) and handed to the
|
|
// provisioner composes n1 through frombus, and the request a node-engine answers for it (the input as the engine
|
|
// sends it, the indexer's manifests in the case) declares the same paths for n1.
|
|
t.Run("the sandbox composes a node as the bus reader does", func(t *testing.T) {
|
|
b, err := frombustest.Provisioned()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, scope := context.Background(), frombus.Scope{Node: frombustest.Node}
|
|
read, err := frombus.Input(ctx, b, frombus.Mesh{}, scope)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, problems, err := compose.Compose(read, frombustest.Node)
|
|
if err != nil || len(problems) > 0 {
|
|
t.Fatalf("the bus reader's input composes n1: %v %v", err, problems)
|
|
}
|
|
want := pathsOf(d)
|
|
sent := SentInput(read, frombustest.Node)
|
|
cases := Case{Name: "change", Manifests: map[string]Manifest{}}
|
|
for name, m := range b.Module {
|
|
cases.Manifests[name] = Manifest{Raw: b.Manifests[m.Manifest]}
|
|
}
|
|
r := withInput(t, Request{V: Version, Machines: []string{frombustest.Node}, Declarations: true, Cases: []Case{cases}}, sent)
|
|
v, err := Run(r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := v.Cases[0].Machines[frombustest.Node]
|
|
if !got.Composes || !reflect.DeepEqual(got.Declared, want) {
|
|
t.Errorf("the sandbox composed n1 %+v; the bus reader declared %+v", got, want)
|
|
}
|
|
})
|
|
// Issue 774 (the check of the bus want, the third of a kind: the sandbox's input differs from what the bus reader
|
|
// composes): a node like the bus node, its bus module folded in its own composition at a build of the old form and no
|
|
// build published for the module's server artifact, composes in the sandbox as its node-engine composes it, from the
|
|
// input that says how (compose.Input.ComposedHow); from an older engine's input, which does not, it is named not
|
|
// judged, never failed and never passed in silence.
|
|
t.Run("a module folded in the node's own composition", func(t *testing.T) {
|
|
bus := `{"module": "bus", "version": "1", "claims": [{"name": "node-files"}], ` +
|
|
`"resources": [{"id": "server", "type": "container", "name": "bus-server", "artifact": "server"}], ` +
|
|
`"build": {"artifacts": [{"name": "server", "kind": "upstream", "from": "nats:2.11@sha256:` + strings.Repeat("a", 64) + `"}]}}`
|
|
man, err := catalogue.Decode([]byte(bus))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
node := compose.Node{Name: "a", Assigned: []string{"bus"}, InOwn: map[string]bool{"bus": true},
|
|
RunsOwn: &delivery.Composed{Node: "a"}}
|
|
in := compose.Input{Catalogue: map[string]catalogue.Manifest{"bus": man}, Nodes: []compose.Node{node}}
|
|
request := func(in compose.Input) Request {
|
|
return withInput(t, Request{V: Version, Machines: []string{"a"}, Depth: DepthCompose,
|
|
Cases: []Case{{Name: "change", Manifests: map[string]Manifest{}}}}, in)
|
|
}
|
|
older, err := Run(request(in))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m := older.Cases[0].Machines["a"]; !m.Composes || !strings.HasPrefix(m.Reason, NotJudged+"bus") {
|
|
t.Errorf("an older engine's input of a node with a folded module: %+v", m)
|
|
}
|
|
in.ComposedHow = &compose.ComposedHow{Node: "a", Builds: map[string]string{}}
|
|
sent, err := Run(request(in))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m := sent.Cases[0].Machines["a"]; !m.Composes || m.Reason != "" {
|
|
t.Errorf("the input that says how the node composes, its bus folded: %+v", m)
|
|
}
|
|
// A module the change refuses beside the folded one fails the node in its words, never passed with the rest
|
|
// composed (review of the sandbox input); held already where the node-engine composed, it stays held as there.
|
|
app, err := catalogue.Decode([]byte(`{"module": "app", "version": "1", ` +
|
|
`"resources": [{"id": "env", "type": "file", "path": "/var/lib/app/env", "mode": "0600", "content": "N=${secret:repository}\n"}]}`))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
in.Catalogue["app"] = app
|
|
in.Nodes[0].Assigned = []string{"bus", "app"}
|
|
refused, err := Run(request(in))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m := refused.Cases[0].Machines["a"]; m.Composes || !strings.Contains(m.Reason, "app: ") || !strings.Contains(m.Reason, "repository") {
|
|
t.Errorf("a module the change refuses on a node composed as its node-engine does: %+v", m)
|
|
}
|
|
// Held composing without the change, blamed for a refusal beyond the read (issue 1960's unset names): no refusal of
|
|
// the change either (review round 1).
|
|
in.ComposedHow.HeldBefore = map[string]string{"app": "its route names are unset"}
|
|
before, err := Run(request(in))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m := before.Cases[0].Machines["a"]; !m.Composes {
|
|
t.Errorf("a module the node holds composing without the change: %+v", m)
|
|
}
|
|
in.ComposedHow.HeldBefore = nil
|
|
in.ComposedHow.Held = map[string]string{"app": "held on the node"}
|
|
held, err := Run(request(in))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if m := held.Cases[0].Machines["a"]; !m.Composes {
|
|
t.Errorf("a module the node-engine holds too: %+v", m)
|
|
}
|
|
})
|
|
v, err := Run(Request{V: Version, Cases: []Case{{Name: "only-read", Manifests: map[string]Manifest{"demo": {Raw: json.RawMessage(demo)}}}}})
|
|
if err != nil || len(v.Cases) != 1 || !v.Cases[0].Manifests["demo"].Accepted || v.Cases[0].Machines != nil || v.SDK == "" {
|
|
t.Fatalf("a request with no machines: %+v, %v", v, err)
|
|
}
|
|
}
|
|
|
|
// The composer judges no manifest (novox/hq ADR 0578 §5): xterm's module.json from mesh-catalog at 835bf22b, whose
|
|
// config value falls back to "font-size", is read whatever list of predefined keys a request carries (a group touching
|
|
// xterm failed its composition on this, group check 18df81380db3); a module whose verdict in the input refuses it is
|
|
// held, composed as its stub, and named in the verdict's words.
|
|
func TestTheComposerTakesTheVerdictsOfItsInput(t *testing.T) {
|
|
raw, err := os.ReadFile("testdata/catalogue-835bf22b-xterm.module.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r := Request{V: Version, Predefined: catalogue.PredefinedList{"something-else": {Type: "string", Description: "x"}},
|
|
Cases: []Case{{Name: "change", Manifests: map[string]Manifest{"xterm": {Raw: raw}}}}}
|
|
v, err := Run(r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := v.Cases[0].Manifests["xterm"]; !got.Accepted {
|
|
t.Fatalf("xterm: %+v, want accepted", got)
|
|
}
|
|
r.Cases[0].Verdicts = map[string]delivery.ManifestVerdict{"xterm": {Module: "xterm", State: delivery.VerdictRefused,
|
|
Problems: []string{"falls back to a key not listed"}, Judge: "src2:j"}}
|
|
shelf, err := parse(r.Cases[0].Manifests, map[string]ManifestRead{}, r.Cases[0].Verdicts)
|
|
if err != nil || !shelf["xterm"].Stubbed {
|
|
t.Fatalf("the refused module is not held as its stub: %+v %v", shelf["xterm"], err)
|
|
}
|
|
if v, err = Run(r); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := v.Cases[0].Manifests["xterm"]; got.Accepted ||
|
|
!strings.Contains(got.Refused, "the indexer's judge (src2:j) refused the manifest of xterm: falls back to a key not listed") {
|
|
t.Fatalf("xterm refused by its verdict: %+v, want refused in the verdict's words", got)
|
|
}
|
|
}
|