jochen
52af210e47
A module's data section says what it keeps and how precious it is; the backup holder's lines, binding stickiness, retirement on unassign and D13's conditions follow from it, so issue 273's empty replacement is said and an unassigned module's data is remembered, not forgotten.
378 lines
13 KiB
Go
378 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"go/ast"
|
|
"go/parser"
|
|
"go/token"
|
|
"path/filepath"
|
|
"reflect"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
)
|
|
|
|
// The schemas the controller serves, verb by verb, as the console receives them: from the
|
|
// announcement, not the table — what is checked is what a caller is shown (novox/hq issue 244).
|
|
func servedSchemas(t *testing.T) map[string]catalogue.Verb {
|
|
t.Helper()
|
|
handlers, behind, err := seatToolHandlers()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(behind) != 0 {
|
|
t.Fatalf("this build cannot run %v of its own seat's verbs", behind)
|
|
}
|
|
served := map[string]catalogue.Verb{}
|
|
for _, e := range seatAnnouncement(handlers).Endpoints {
|
|
var input map[string]any
|
|
if err := json.Unmarshal([]byte(e.Metadata["schema"]), &input); err != nil {
|
|
t.Fatalf("%s announces a schema that is not JSON: %v", e.Name, err)
|
|
}
|
|
served[e.Metadata["tool"]] = catalogue.Verb{Name: e.Metadata["tool"], Input: input}
|
|
}
|
|
if len(served) != len(catalogue.ControllerVerbs) {
|
|
t.Fatalf("%d verbs served for %d in the table", len(served), len(catalogue.ControllerVerbs))
|
|
}
|
|
return served
|
|
}
|
|
|
|
// subsetsOf is every subset of the names, the empty one included.
|
|
func subsetsOf(names []string) [][]string {
|
|
var out [][]string
|
|
for mask := 0; mask < 1<<len(names); mask++ {
|
|
var s []string
|
|
for i, n := range names {
|
|
if mask&(1<<i) != 0 {
|
|
s = append(s, n)
|
|
}
|
|
}
|
|
out = append(out, s)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func argumentsFor(subset []string, switches map[string]bool) map[string]any {
|
|
args := map[string]any{}
|
|
for _, n := range subset {
|
|
if switches[n] {
|
|
args[n] = "true"
|
|
} else {
|
|
args[n] = "x-" + n
|
|
}
|
|
}
|
|
return args
|
|
}
|
|
|
|
// saidOutright are the switches that say the default aloud, so the line is the same without them —
|
|
// on purpose, and only these.
|
|
var saidOutright = map[string]string{
|
|
"push": "behind", // the whole mesh is what no machine means; behind lets a caller say they meant it
|
|
}
|
|
|
|
// **No argument a caller gives is passed over** (novox/hq issue 244). For every verb served and
|
|
// every combination of the arguments its schema declares, the verb either refuses the call, or
|
|
// composes a command line that each given argument changed: taking any one away changes the line
|
|
// or makes it refused. An argument the line is the same without is one the verb ignored — the
|
|
// shape of the push that named a machine and pushed every machine behind.
|
|
func TestNoArgumentAVerbIsGivenIsPassedOver(t *testing.T) {
|
|
for name, v := range servedSchemas(t) {
|
|
if inProcess[name] {
|
|
continue
|
|
}
|
|
names, switches := declaredArguments(v)
|
|
for _, subset := range subsetsOf(names) {
|
|
args := argumentsFor(subset, switches)
|
|
argv, err := argvFor(name, args)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "does not declare") {
|
|
t.Errorf("%s %v: %v", name, args, err)
|
|
}
|
|
continue
|
|
}
|
|
for _, dropped := range subset {
|
|
fewer := map[string]any{}
|
|
for k, val := range args {
|
|
if k != dropped {
|
|
fewer[k] = val
|
|
}
|
|
}
|
|
without, err := argvFor(name, fewer)
|
|
if err == nil && reflect.DeepEqual(argv, without) && saidOutright[name] != dropped {
|
|
t.Errorf("%s ignores %q given with %v: %v either way", name, dropped, subset, argv)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// **An argument a verb does not declare is refused, naming it — never dropped.** Every verb, with
|
|
// what it requires and one argument more; and `node` in particular, for every verb whose schema
|
|
// does not take a machine.
|
|
func TestAnArgumentAVerbDoesNotDeclareIsRefused(t *testing.T) {
|
|
for name, v := range servedSchemas(t) {
|
|
names, _ := declaredArguments(v)
|
|
strangers := []string{"no-such-argument"}
|
|
if !contains(names, "node") {
|
|
strangers = append(strangers, "node")
|
|
}
|
|
for _, stranger := range strangers {
|
|
args := sampleArguments(v)
|
|
args[stranger] = "x"
|
|
_, err := argvFor(name, args)
|
|
if inProcess[name] {
|
|
_, err = readArguments(name, args)
|
|
}
|
|
if err == nil || !strings.Contains(err.Error(), strconv.Quote(stranger)) {
|
|
t.Errorf("%s took %q, which it does not declare: %v", name, stranger, err)
|
|
}
|
|
}
|
|
}
|
|
if _, err := argvFor("clear", map[string]any{"dead": "yes"}); err == nil {
|
|
t.Error("a switch took a word that is neither true nor false, and would have read it as false")
|
|
}
|
|
if _, err := argvFor("node", map[string]any{"node": 7}); err == nil {
|
|
t.Error("a number was taken as a machine's name, or as no machine")
|
|
}
|
|
if argv, err := argvFor("clear", map[string]any{"dead": true}); err != nil || strings.Join(argv, " ") != "clear --dead" {
|
|
t.Errorf("a switch given as JSON true: %v %v", argv, err)
|
|
}
|
|
}
|
|
|
|
// The push that was the cause: a machine named is that machine; none named is the whole mesh, and
|
|
// naming one beside behind is refused rather than one of the two guessed.
|
|
func TestAPushIsOneMachineOrSaysItIsTheWholeMesh(t *testing.T) {
|
|
argv, err := argvFor("push", map[string]any{"node": "g1", "why": "w"})
|
|
if err != nil || strings.Join(argv, " ") != "push g1 --wait 0 --why w" {
|
|
t.Fatalf("a named push: %v %v", argv, err)
|
|
}
|
|
for _, args := range []map[string]any{{"why": "w"}, {"behind": "true", "why": "w"}} {
|
|
argv, err := argvFor("push", args)
|
|
if err != nil || strings.Join(argv, " ") != "push --behind --wait 0 --why w" {
|
|
t.Fatalf("a push of the whole mesh %v: %v %v", args, argv, err)
|
|
}
|
|
}
|
|
if _, err := argvFor("push", map[string]any{"node": "g1", "behind": "true", "why": "w"}); err == nil ||
|
|
!strings.Contains(err.Error(), `"behind"`) {
|
|
t.Fatalf("a named push with behind was taken: %v", err)
|
|
}
|
|
if _, err := argvFor("push", map[string]any{"machine": "g1"}); err == nil || !strings.Contains(err.Error(), `"machine"`) {
|
|
t.Fatalf("a push given the machine under another name ran as a push of every machine: %v", err)
|
|
}
|
|
}
|
|
|
|
// commandFlags is every flag set this package's commands parse, by the name the set is made with,
|
|
// and the flags defined on it — read from the source, so a flag added to a command is seen here
|
|
// without anyone remembering to.
|
|
func commandFlags(t *testing.T) map[string][]string {
|
|
t.Helper()
|
|
files, err := filepath.Glob("*.go")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fset := token.NewFileSet()
|
|
out := map[string][]string{}
|
|
for _, f := range files {
|
|
if strings.HasSuffix(f, "_test.go") {
|
|
continue
|
|
}
|
|
file, err := parser.ParseFile(fset, f, nil, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, decl := range file.Decls {
|
|
fn, ok := decl.(*ast.FuncDecl)
|
|
if !ok || fn.Body == nil {
|
|
continue
|
|
}
|
|
sets := map[string]string{} // variable → the set's name
|
|
ast.Inspect(fn.Body, func(n ast.Node) bool {
|
|
if assign, ok := n.(*ast.AssignStmt); ok && len(assign.Lhs) == 1 && len(assign.Rhs) == 1 {
|
|
if call, ok := assign.Rhs[0].(*ast.CallExpr); ok && isSelector(call.Fun, "flag", "NewFlagSet") {
|
|
if id, ok := assign.Lhs[0].(*ast.Ident); ok {
|
|
if name, ok := stringLit(call.Args[0]); ok {
|
|
sets[id.Name] = name
|
|
out[name] = append(out[name], []string{}...)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
call, ok := n.(*ast.CallExpr)
|
|
if !ok {
|
|
return true
|
|
}
|
|
sel, ok := call.Fun.(*ast.SelectorExpr)
|
|
if !ok {
|
|
return true
|
|
}
|
|
recv, ok := sel.X.(*ast.Ident)
|
|
if !ok || sets[recv.Name] == "" {
|
|
return true
|
|
}
|
|
arg := 0
|
|
switch sel.Sel.Name {
|
|
case "Bool", "String", "Int", "Int64", "Uint", "Uint64", "Float64", "Duration", "Func", "BoolFunc", "TextVar":
|
|
case "BoolVar", "StringVar", "IntVar", "Int64Var", "UintVar", "Uint64Var", "Float64Var", "DurationVar", "Var":
|
|
arg = 1
|
|
default:
|
|
return true
|
|
}
|
|
if arg < len(call.Args) {
|
|
if flagName, ok := stringLit(call.Args[arg]); ok {
|
|
out[sets[recv.Name]] = append(out[sets[recv.Name]], flagName)
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func isSelector(e ast.Expr, pkg, name string) bool {
|
|
sel, ok := e.(*ast.SelectorExpr)
|
|
if !ok {
|
|
return false
|
|
}
|
|
id, ok := sel.X.(*ast.Ident)
|
|
return ok && id.Name == pkg && sel.Sel.Name == name
|
|
}
|
|
|
|
func stringLit(e ast.Expr) (string, bool) {
|
|
lit, ok := e.(*ast.BasicLit)
|
|
if !ok || lit.Kind != token.STRING {
|
|
return "", false
|
|
}
|
|
s, err := strconv.Unquote(lit.Value)
|
|
return s, err == nil
|
|
}
|
|
|
|
// accountedFlags are the flags of a verb's command that are not an argument of the same name:
|
|
// carried by an argument named otherwise ("=argument"), or set by the verb itself, or withheld from
|
|
// the named verb on purpose — each with why. `command` reaches every flag of the binary regardless.
|
|
var accountedFlags = map[string]map[string]string{
|
|
"status": {"json": "set by the verb: the answer is data"},
|
|
"seats": {"json": "set by the verb: the answer is data"},
|
|
"queue": {"json": "not set: the verb answers the table a person reads"},
|
|
"plan": {"json": "set by the verb unless files is asked"},
|
|
"push": {"wait": "set by the verb to 0: a tool call cannot hold a connection for a whole apply"},
|
|
"build": {
|
|
"wait": "set by the verb to 0: the id follows the build (issue 176)",
|
|
"self": "set by the verb from the repository's form: a path on the forge, or a URL",
|
|
"dry-run": "withheld: a dry run answers only when the build ends, which a call cannot wait for; `command` reaches it",
|
|
"behind": "withheld: the named verb builds one named repository; `command` reaches the rest",
|
|
"on": "withheld: the named verb builds one named repository; `command` reaches the rest",
|
|
},
|
|
"builds": {"n": "=limit"},
|
|
"plans": {"n": "=limit", "what-if": "=repository"},
|
|
"durations": {
|
|
"json": "set by the verb: the answer is data",
|
|
"all": "withheld: every measurement of a fortnight is more than a call should carry; `command` reaches it",
|
|
},
|
|
"hand-acts": {"json": "set by the verb: the answer is data"},
|
|
"conditions": {"json": "set by the verb: the answer is data"},
|
|
"retire": {"json": "set by the verb: the answer is data"},
|
|
"cleanup": {"json": "set by the verb: the answer is data"},
|
|
"data": {"json": "set by the verb: the answer is data"},
|
|
"conditions history": {"json": "set by the verb: the answer is data"},
|
|
"conditions show": {"json": "set by the verb: the answer is data"},
|
|
"healers": {"json": "set by the verb: the answer is data"},
|
|
}
|
|
|
|
// **Every flag of the command a verb runs is in the verb's schema, or accounted for here.** Derived
|
|
// from the source, so a flag added to a command — or a verb added whose command takes flags —
|
|
// fails this until somebody decides, in writing, how a caller reaches it (novox/hq issue 244). And
|
|
// a flag accounted for that no longer exists fails too, so the table cannot rot into a list nobody
|
|
// reads.
|
|
func TestEveryFlagOfAVerbsCommandIsAnArgumentOrAccountedFor(t *testing.T) {
|
|
flags := commandFlags(t)
|
|
if len(flags["push"]) == 0 || len(flags["plan"]) == 0 {
|
|
t.Fatalf("reading the commands' flags found nothing for push or plan: %v", flags)
|
|
}
|
|
reached := map[string]map[string]bool{} // verb → flag sets its command lines reach
|
|
served := servedSchemas(t)
|
|
for name, v := range served {
|
|
if inProcess[name] || name == "command" {
|
|
continue
|
|
}
|
|
names, switches := declaredArguments(v)
|
|
for _, subset := range subsetsOf(names) {
|
|
argv, err := argvFor(name, argumentsFor(subset, switches))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// The flag set is named by the longest run of leading words that names one.
|
|
var words []string
|
|
for _, w := range argv {
|
|
if strings.HasPrefix(w, "-") {
|
|
break
|
|
}
|
|
words = append(words, w)
|
|
}
|
|
for n := len(words); n > 0; n-- {
|
|
if _, has := flags[strings.Join(words[:n], " ")]; has {
|
|
if reached[name] == nil {
|
|
reached[name] = map[string]bool{}
|
|
}
|
|
reached[name][strings.Join(words[:n], " ")] = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
used := map[string]map[string]bool{}
|
|
verbs := make([]string, 0, len(reached))
|
|
for verb := range reached {
|
|
verbs = append(verbs, verb)
|
|
}
|
|
sort.Strings(verbs)
|
|
for _, verb := range verbs {
|
|
declared, _ := declaredArguments(served[verb])
|
|
for set := range reached[verb] {
|
|
if used[set] == nil {
|
|
used[set] = map[string]bool{}
|
|
}
|
|
for _, flagName := range flags[set] {
|
|
why, accounted := accountedFlags[set][flagName]
|
|
switch {
|
|
case accounted && strings.HasPrefix(why, "="):
|
|
used[set][flagName] = true
|
|
if !contains(declared, strings.TrimPrefix(why, "=")) {
|
|
t.Errorf("%s: --%s of `%s` is said to be carried by %q, which the schema does not declare",
|
|
verb, flagName, set, strings.TrimPrefix(why, "="))
|
|
}
|
|
case accounted:
|
|
used[set][flagName] = true
|
|
case contains(declared, flagName):
|
|
default:
|
|
t.Errorf("%s runs `%s`, which takes --%s, and the verb's schema has no %q: declare it, "+
|
|
"or say in accountedFlags why a caller does not reach it", verb, set, flagName, flagName)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for set, fs := range accountedFlags {
|
|
for flagName := range fs {
|
|
if !used[set][flagName] {
|
|
t.Errorf("accountedFlags names --%s of `%s`, which no verb's command takes any more", flagName, set)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Every verb's required arguments are properties of its schema: a schema that requires what it
|
|
// does not describe is the uncallable verb of issue 244 from the other side.
|
|
func TestEveryRequiredArgumentIsDescribed(t *testing.T) {
|
|
for name, v := range servedSchemas(t) {
|
|
names, _ := declaredArguments(v)
|
|
for k := range sampleArguments(v) {
|
|
if !contains(names, k) {
|
|
t.Errorf("%s requires %q and does not describe it", name, k)
|
|
}
|
|
}
|
|
}
|
|
}
|