jochen
801552c0eb
A push outlasted the console's 30s wait and, when it sent the bus its changed user list, the broker's reload forgot the reply it may send: the push happened and its caller was told it did not answer. Calls now answer in full or as running with an id, a push answers before it sends, refused answers are recorded on their call, and 'calls' reads them back.
366 lines
12 KiB
Go
366 lines
12 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"})
|
|
if err != nil || strings.Join(argv, " ") != "push g1 --wait 0" {
|
|
t.Fatalf("a named push: %v %v", argv, err)
|
|
}
|
|
for _, args := range []map[string]any{{}, {"behind": "true"}} {
|
|
argv, err := argvFor("push", args)
|
|
if err != nil || strings.Join(argv, " ") != "push --behind --wait 0" {
|
|
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"}); 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"},
|
|
}
|
|
|
|
// **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)
|
|
}
|
|
}
|
|
}
|
|
}
|