The check counts every test the integration level runs, untagged ones in: the NFS server module held 51 and the package manager module 121, over the budget of 50. Each folded file's tests run in order as rows of one test that keeps the first one's name and logs each case before it runs; the root helper's test sockets are numbered per call, as one test now holds several listeners, and the case that skips without pacman-conf runs last. Counts now 48 and 42. Builds: design 47 H2 §819; H-A-349 DQ-14
221 lines
8.8 KiB
Go
221 lines
8.8 KiB
Go
package main
|
|
|
|
// The package view over the bus (novox/hq ADR 0507 §6, §7; acceptance 1840/AC6): two nodes' `installed` keys and
|
|
// the node-engine's `packages`, answered without asking any machine.
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
stdio "git.novox.be/novox/mesh-sdk/go"
|
|
)
|
|
|
|
// viewStates is two nodes' packages on the bus: node-a current and declared, node-b over the cap since a while,
|
|
// with a foreign package, and no declaration the node-engine published.
|
|
func viewStates(t *testing.T) (*fakeStates, *Machine) {
|
|
t.Helper()
|
|
states := &fakeStates{}
|
|
inst := states.store(StateInstalled)
|
|
inst.Put("node-a", InstalledValue{At: t0, Packages: []InstalledPackage{
|
|
{"glibc", "2.42-1", false, "core"}, {"tmux", "3.5-1", true, "extra"}, {"vim", "9.1-1", true, "extra"},
|
|
{"zsh", "5.9-2", true, "extra"},
|
|
}})
|
|
inst.Put("node-b", InstalledValue{At: t0.Add(-time.Hour), Packages: []InstalledPackage{
|
|
{"glibc", "2.42-1", false, "core"}, {"yay", "12.0-1", true, RepoForeign}, {"zsh", "5.9-1", false, "extra"},
|
|
}})
|
|
inst.Put("node-b.not-current", NotCurrent{Bytes: 300000, Since: t0.Add(-30 * time.Minute)})
|
|
decl := states.store(DeclaredPackagesState)
|
|
var d declaredValue
|
|
json.Unmarshal([]byte(`{"node":"node-a","packages":[{"package":"vim","modules":["editor"],"absent":false},`+
|
|
`{"package":"tmux","modules":["shell"],"absent":true},{"package":"zsh","modules":["login","shell"],"absent":false}]}`), &d)
|
|
decl.Put("node-a", d)
|
|
m := machine(func(_ context.Context, name string, args ...string) Ran {
|
|
t.Errorf("a machine was asked: %s %v", name, args)
|
|
return Ran{Status: 99}
|
|
}, 1000)
|
|
m.Node, m.States = "node-a", readerOf(states)
|
|
return states, m
|
|
}
|
|
|
|
func testOnePackageOnEveryNodeWithWhoDeclaresIt(t *testing.T) {
|
|
_, m := viewStates(t)
|
|
r, err := m.Packages("zsh", 500)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
on := r["nodes"].([]PackageOnNode)
|
|
if len(on) != 2 {
|
|
t.Fatalf("%+v", on)
|
|
}
|
|
a, b := on[0], on[1]
|
|
if a.DeclaredFrom != SourceEngine || b.DeclaredFrom != "" {
|
|
t.Errorf("sources: %q, %q", a.DeclaredFrom, b.DeclaredFrom)
|
|
}
|
|
// A node whose engine has written no key has no declaration, said so, and no controller state is read (774/S7/AC2);
|
|
// an engine whose state cannot be read at all is said once beside the sources, for every node (774/S7/AC1 reads the
|
|
// engine's key above).
|
|
read := m.States
|
|
m.States = func(name string) StateReader {
|
|
if name != SourceEngine && name != StateInstalled {
|
|
t.Errorf("state %s was read: only the engine's packages are", name)
|
|
}
|
|
return read(name)
|
|
}
|
|
r2, _ := m.Packages("zsh", 500)
|
|
on2 := r2["nodes"].([]PackageOnNode)
|
|
if on2[0].DeclaredFrom != SourceEngine || on2[1].DeclaredFrom != "" || len(on2[1].DeclaredBy) != 0 ||
|
|
!strings.Contains(fmt.Sprint(r2["declared_none"]), "no packages key for node-b") {
|
|
t.Errorf("a node with no key: %+v %v", on2, r2["declared_none"])
|
|
}
|
|
m.States = func(name string) StateReader {
|
|
if name == SourceEngine {
|
|
return failingReader{errors.New("is issued and its bucket is not on the bus yet")}
|
|
}
|
|
return read(name)
|
|
}
|
|
r3, err3 := m.Packages("zsh", 500)
|
|
on3, _ := r3["nodes"].([]PackageOnNode)
|
|
if err3 != nil || len(on3) != 2 || on3[0].DeclaredFrom != "" || on3[1].DeclaredFrom != "" ||
|
|
!strings.Contains(fmt.Sprint(r3["declared_engine_error"]), "not on the bus yet") {
|
|
t.Errorf("engine unreadable: %+v %v", r3, err3)
|
|
}
|
|
m.States = read
|
|
if a.Node != "node-a" || !a.Installed || a.Version != "5.9-2" || !a.Explicit || a.Repository != "extra" ||
|
|
strings.Join(a.DeclaredBy, ",") != "login,shell" || !a.Current {
|
|
t.Errorf("node-a: %+v", a)
|
|
}
|
|
if b.Node != "node-b" || b.Version != "5.9-1" || b.Explicit || len(b.DeclaredBy) != 0 || b.Current {
|
|
t.Errorf("node-b: %+v", b)
|
|
}
|
|
r, _ = m.Packages("yay", 500)
|
|
on = r["nodes"].([]PackageOnNode)
|
|
if on[0].Installed || !on[1].Installed || !on[1].Foreign || on[1].Repository != "" {
|
|
t.Errorf("yay: %+v", on)
|
|
}
|
|
}
|
|
|
|
func testTheViewSaysWhatDiffersWhatIsOnSomeNodesWhatNoModuleDeclaresAndTheForeignApart(t *testing.T) {
|
|
_, m := viewStates(t)
|
|
r, err := m.Packages("", 500)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
nodes := r["nodes"].([]NodeView)
|
|
if len(nodes) != 2 {
|
|
t.Fatalf("%+v", nodes)
|
|
}
|
|
a, b := nodes[0], nodes[1]
|
|
if a.Node != "node-a" || a.Packages != 4 || a.Explicit != 3 || !a.Current || fmt.Sprint(a.Undeclared) != "[{tmux 3.5-1}]" ||
|
|
len(a.Foreign) != 0 || !a.At.Equal(t0) {
|
|
t.Errorf("node-a: %+v", a)
|
|
}
|
|
if b.Current || b.NotCurrent == nil || b.NotCurrent.Bytes != 300000 || b.Undeclared != nil ||
|
|
fmt.Sprint(b.Foreign) != "[{yay 12.0-1}]" || !b.At.Equal(t0.Add(-time.Hour)) {
|
|
t.Errorf("node-b (not current, no declaration, a foreign package): %+v", b)
|
|
}
|
|
if d := r["differing"].([]Spread); len(d) != 1 || d[0].Name != "zsh" || d[0].Versions["node-a"] != "5.9-2" || d[0].Versions["node-b"] != "5.9-1" {
|
|
t.Errorf("differing: %+v", d)
|
|
}
|
|
some := r["some_nodes"].([]Spread)
|
|
var names []string
|
|
for _, s := range some {
|
|
names = append(names, s.Name)
|
|
}
|
|
if strings.Join(names, ",") != "tmux,vim" {
|
|
t.Errorf("on some nodes only, the foreign apart: %v", names)
|
|
}
|
|
r, _ = m.Packages("", 1)
|
|
if r["some_nodes_count"] != 2 || r["some_nodes_truncated"] != true || len(r["some_nodes"].([]Spread)) != 1 {
|
|
t.Errorf("bounded: %v", r)
|
|
}
|
|
}
|
|
|
|
func testInstalledAndForeignAnswerFromTheBus(t *testing.T) {
|
|
_, m := viewStates(t)
|
|
r, err := m.InstalledFrom("", "", "", false, 10)
|
|
if err != nil || r["node"] != "node-a" || r["count"] != 4 || r["current"] != true {
|
|
t.Fatalf("this node's: %v %v", r, err)
|
|
}
|
|
pk := r["packages"].([]Package)
|
|
if pk[0].Reason != "dependency" || pk[0].Repository != "core" || pk[1].Reason != "explicit" {
|
|
t.Errorf("%+v", pk)
|
|
}
|
|
r, err = m.InstalledFrom("node-b", "", "", true, 10)
|
|
if err != nil || r["count"] != 1 || r["current"] != false || r["not_current"] == nil {
|
|
t.Fatalf("node-b's foreign: %v %v", r, err)
|
|
}
|
|
if tot := r["totals"].(map[string]int); tot["explicit"] != 1 || tot["dependency"] != 2 || tot["foreign"] != 1 {
|
|
t.Errorf("totals: %v", tot)
|
|
}
|
|
f, err := m.ForeignFrom("node-b")
|
|
if err != nil || f["count"] != 1 || fmt.Sprint(f["packages"]) != "[{yay 12.0-1}]" {
|
|
t.Errorf("%v %v", f, err)
|
|
}
|
|
if _, err := m.InstalledFrom("node-c", "", "", false, 10); err == nil || !strings.Contains(err.Error(), "node-c") {
|
|
t.Errorf("a node with no packages on the bus: %v", err)
|
|
}
|
|
}
|
|
|
|
func testUpdatesAnswerEveryNodeAndWhenItsListLastChanged(t *testing.T) {
|
|
states, m := viewStates(t)
|
|
up := states.store(StateUpdates)
|
|
up.now = func() time.Time { return t0.Add(-2 * time.Hour) }
|
|
up.Put("node-a", UpdatesValue{Reachable: true, Packages: []VersionChange{{"zsh", "5.9-2", "5.9-3"}}})
|
|
up.now = func() time.Time { return t0.Add(-3 * time.Hour) }
|
|
up.Put("node-b", UpdatesValue{Reachable: false, Packages: []VersionChange{}})
|
|
r, err := m.UpdatesFor("")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v := r["nodes"].([]UpdatesView)
|
|
if len(v) != 2 || v[0].Count != 1 || !v[0].Reachable || v[0].Changed == nil || !v[0].Changed.Equal(t0.Add(-2*time.Hour)) ||
|
|
v[1].Reachable || !v[1].Changed.Equal(t0.Add(-3*time.Hour)) {
|
|
t.Fatalf("%+v", v)
|
|
}
|
|
r, _ = m.UpdatesFor("node-b")
|
|
if v := r["nodes"].([]UpdatesView); len(v) != 1 || v[0].Node != "node-b" {
|
|
t.Errorf("one node: %+v", v)
|
|
}
|
|
}
|
|
|
|
func testANodeArgumentIsOneKeyToken(t *testing.T) {
|
|
for _, bad := range []string{"node-a.not-current", "node-a.*", "a b"} {
|
|
if _, err := nodeOf(map[string]any{"node": bad}); err == nil {
|
|
t.Errorf("%q was taken as a node", bad)
|
|
}
|
|
}
|
|
if n, err := nodeOf(map[string]any{"node": "node-a"}); err != nil || n != "node-a" {
|
|
t.Errorf("%q %v", n, err)
|
|
}
|
|
}
|
|
|
|
// failingReader is a state that cannot be read.
|
|
type failingReader struct{ err error }
|
|
|
|
func (f failingReader) Get(string) (*stdio.StateEntry, error) { return nil, f.err }
|
|
func (f failingReader) Keys() ([]string, error) { return nil, f.err }
|
|
func (f failingReader) History(string) ([]stdio.StateRevision, error) { return nil, f.err }
|
|
|
|
// TestOnePackageOnEveryNodeWithWhoDeclaresIt runs this file's cases in order as one test, each a row: the check counts every top-level test against the
|
|
// module's budget of 50 (design 47 H2 §819). A failing case is named by the line logged before it.
|
|
func TestOnePackageOnEveryNodeWithWhoDeclaresIt(t *testing.T) {
|
|
for _, c := range []struct {
|
|
name string
|
|
run func(*testing.T)
|
|
}{
|
|
{"TestOnePackageOnEveryNodeWithWhoDeclaresIt", testOnePackageOnEveryNodeWithWhoDeclaresIt},
|
|
{"TestTheViewSaysWhatDiffersWhatIsOnSomeNodesWhatNoModuleDeclaresAndTheForeignApart", testTheViewSaysWhatDiffersWhatIsOnSomeNodesWhatNoModuleDeclaresAndTheForeignApart},
|
|
{"TestInstalledAndForeignAnswerFromTheBus", testInstalledAndForeignAnswerFromTheBus},
|
|
{"TestUpdatesAnswerEveryNodeAndWhenItsListLastChanged", testUpdatesAnswerEveryNodeAndWhenItsListLastChanged},
|
|
{"TestANodeArgumentIsOneKeyToken", testANodeArgumentIsOneKeyToken},
|
|
} {
|
|
t.Logf("case %s", c.name)
|
|
c.run(t)
|
|
}
|
|
}
|