mesh-delivery/modules/mesh-delivery-checker/cmd/mesh-delivery-checker-tools/main_test.go

package main

import (
	"encoding/json"
	"errors"
	"os"
	"slices"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-checker/checkermsg"

	"mesh-delivery-checker/internal/check"
)

func TestTheToolsServedAreTheFiveReadTools(t *testing.T) {
	var names []string
	for _, tl := range Tools(check.Reader{}) {
		names = append(names, tl.Name)
		if tl.Description == "" || tl.Run == nil {
			t.Errorf("%s has no description or no run", tl.Name)
		}
	}
	want := []string{check.VerdictsReadTool, check.PullReadTool, check.KeptReadTool, check.PreviewsReadTool, check.StatusReadTool}
	if !slices.Equal(names, want) {
		t.Errorf("tools = %v, want %v", names, want)
	}
	// The recovery tool beside them asks a lost check again; with nothing to write it refuses.
	recovery := RecoveryTools(check.Reader{}, nil)
	if len(recovery) != 1 || recovery[0].Name != check.AskAgainTool || recovery[0].Description == "" {
		t.Errorf("recovery tools = %+v", recovery)
	}
	if _, err := recovery[0].Run(map[string]any{"group": "feat/x", "why": "lost"}); err == nil {
		t.Errorf("%s answered with no state to write", check.AskAgainTool)
	}
	// With nothing to read from a tool says so and changes nothing.
	for _, tl := range Tools(check.Reader{}) {
		if tl.Name == check.StatusReadTool {
			continue // it answers from what it can read, and says what it could not
		}
		if _, err := tl.Run(map[string]any{"repository": "novox/x", "number": float64(1)}); err == nil {
			t.Errorf("%s answered with no state to read", tl.Name)
		}
	}
}

// memStore is a tries state in memory.
type memStore struct{ vals map[string]json.RawMessage }

func (m *memStore) Keys() ([]string, error) {
	var out []string
	for k := range m.vals {
		out = append(out, k)
	}
	return out, nil
}
func (m *memStore) Get(key string) (json.RawMessage, error) { return m.vals[key], nil }
func (m *memStore) Create(key string, value []byte) error {
	if _, ok := m.vals[key]; ok {
		return errors.New("exists")
	}
	m.vals[key] = value
	return nil
}

func (m *memStore) Entry(key string) (json.RawMessage, uint64, error) { return m.vals[key], 1, nil }
func (m *memStore) Update(key string, value []byte, revision uint64) error {
	m.vals[key] = value
	return nil
}

func TestTheTryToolsAskAndReadATry(t *testing.T) { // ADR 0501 §5, the agreed interface with mesh-controller's try
	store := &memStore{vals: map[string]json.RawMessage{}}
	tools := TryTools(Trying{Tries: store, Ender: store, Now: func() time.Time { return time.Unix(1, 5) },
		Trunks: func() (map[string]string, error) {
			return map[string]string{"novox/mesh-delivery": strings.Repeat("a", 40)}, nil
		}})
	if len(tools) != 3 || tools[0].Name != "checker_try" || tools[1].Name != "checker_try_read" || tools[2].Name != "checker_try_end" {
		t.Fatalf("tools = %+v", tools)
	}
	out, err := tools[0].Run(map[string]any{"repository": "novox/mesh-delivery", "head": strings.Repeat("1", 40), "trunk": "main"})
	if err != nil {
		t.Fatal(err)
	}
	id := out.(map[string]any)["id"].(string)
	if id != "try-1000000005" {
		t.Errorf("id = %q", id)
	}
	raw, err := tools[1].Run(map[string]any{"id": id})
	if err != nil || !strings.Contains(string(raw.(json.RawMessage)), `"state":"queued"`) {
		t.Errorf("read = %s, %v", raw, err)
	}
	// The seat's verbs answer as the tools do (ADR 0547 §10, issue 774): the same ask is the same try, and the read is alike.
	verbs := SeatTryTools(Trying{Tries: store, Ender: store, Now: func() time.Time { return time.Unix(1, 5) },
		Trunks: func() (map[string]string, error) {
			return map[string]string{"novox/mesh-delivery": strings.Repeat("a", 40)}, nil
		}})
	if len(verbs) != 3 || verbs[0].Name != Seat+".try" || verbs[1].Name != Seat+".try-read" || verbs[2].Name != Seat+".try-end" {
		t.Fatalf("verbs = %+v", verbs)
	}
	again, err := verbs[0].Run(map[string]any{"repository": "novox/mesh-delivery", "head": strings.Repeat("1", 40), "trunk": "main"})
	if err != nil || again.(map[string]any)["id"] != id {
		t.Errorf("verb try = %v, %v, want the waiting try %s", again, err, id)
	}
	if viaVerb, err := verbs[1].Run(map[string]any{"id": id}); err != nil || string(viaVerb.(json.RawMessage)) != string(raw.(json.RawMessage)) {
		t.Errorf("verb try-read = %s, %v; tool = %s", viaVerb, err, raw)
	}
	if _, err := verbs[0].Run(map[string]any{"repository": "novox/hq", "head": strings.Repeat("1", 40)}); err == nil {
		t.Error("the verb tried a repository nothing checks")
	}
	// The seat's definition of the verb try gives the members the verb serves (ADR 0637 §6), as the tool takes them, and says so.
	def, err := os.ReadFile("../../../../contracts/seats/mesh-delivery-checker/seat.json")
	if err != nil {
		t.Fatal(err)
	}
	var seat struct {
		Verbs []struct {
			Name        string `json:"name"`
			Description string `json:"description"`
			Input       struct {
				Properties map[string]any `json:"properties"`
				Required   []string       `json:"required"`
			} `json:"input"`
		} `json:"verbs"`
	}
	if err := json.Unmarshal(def, &seat); err != nil {
		t.Fatal(err)
	}
	for _, v := range seat.Verbs {
		if v.Name != "try" {
			continue
		}
		toolProps := verbs[0].Input["properties"].(map[string]any)
		for name := range toolProps {
			if _, ok := v.Input.Properties[name]; !ok {
				t.Errorf("the verb try serves no %q, which the tool takes", name)
			}
		}
		const limit = "at most 4 run on a build node, and 8 wait for one, mesh-wide"
		if !strings.Contains(v.Description, limit) || !strings.Contains(verbs[0].Description, limit) {
			t.Errorf("the verb and the tool state one limit %q", limit)
		}
		if len(v.Input.Required) != 0 || !strings.Contains(v.Description, "members") {
			t.Errorf("the verb try requires %v and says %q: want members as an alternative to one repository and head", v.Input.Required, v.Description)
		}
	}
	// A group try (issue 1921): the members, each an exact commit; members and one repository together are refused; the
	// description says what it does in the words a search for "try a group" finds.
	later := TryTools(Trying{Tries: store, Ender: store, Now: func() time.Time { return time.Unix(2, 5) },
		Trunks: func() (map[string]string, error) {
			return map[string]string{"novox/mesh-delivery": strings.Repeat("a", 40)}, nil
		}})
	g, err := later[0].Run(map[string]any{"members": []any{map[string]any{"repository": "novox/mesh-delivery", "head": strings.Repeat("2", 40)}}})
	if err != nil || g.(map[string]any)["id"] == id {
		t.Errorf("a group try = %v, %v, want a try of its own", g, err)
	}
	if _, err := tools[0].Run(map[string]any{"members": []any{map[string]any{"repository": "novox/mesh-delivery", "head": strings.Repeat("2", 40)}},
		"repository": "novox/mesh-delivery", "head": strings.Repeat("1", 40)}); err == nil {
		t.Error("members and a repository were both taken")
	}
	if _, err := tools[0].Run(map[string]any{"members": "novox/mesh-delivery"}); err == nil {
		t.Error("members that are no list were taken")
	}
	for _, tl := range tools {
		for _, words := range []string{"group"} {
			if !strings.Contains(strings.ToLower(tl.Description), words) {
				t.Errorf("%s says nothing of a %s: %q", tl.Name, words, tl.Description)
			}
		}
	}
	if d := strings.ToLower(tools[0].Description); !strings.Contains(d, "try a group") || !strings.Contains(d, "exact commit") || !strings.Contains(d, "every failure") ||
		!strings.Contains(d, "composition on every placed node") || !strings.Contains(d, "owes the forge nothing") || !strings.Contains(d, "kept") {
		t.Errorf("the try's description does not say what a group try does: %q", d)
	}
	if open := OpenTriesTools(Trying{Tries: store}); len(open) != 1 || open[0].Name != check.TriesTool || !strings.Contains(open[0].Description, "try.started") {
		t.Errorf("open tries tool = %+v", open)
	} else if out, err := open[0].Run(nil); err != nil || len(out.(map[string]any)["tries"].([]checkermsg.Open)) != 2 {
		t.Errorf("open tries = %v, %v, want the two tries asked", out, err)
	}
	// Issue 734: a try whose ask was lost is ended by hand with why, and its head is asked anew.
	ended, err := tools[2].Run(map[string]any{"id": id, "why": "its ask was lost"})
	if err != nil || ended.(map[string]any)["state"] != "error" {
		t.Errorf("end = %v, %v", ended, err)
	}
	if _, err := tools[2].Run(map[string]any{"id": id, "why": "again"}); err == nil {
		t.Error("an ended try was ended again")
	}
	if _, err := tools[0].Run(map[string]any{"repository": "novox/hq", "head": strings.Repeat("1", 40)}); err == nil ||
		err.Error() != "no level of novox/hq is checked by the checker" {
		t.Errorf("hq: %v", err)
	}
}