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

package main

import (
	"encoding/json"
	"strings"
	"testing"

	"mesh-delivery-view/internal/view"
)

type fake map[string]string

func (f fake) reader() view.Reader {
	return view.Reader{State: view.StateRead{
		Keys: func() ([]string, error) {
			var k []string
			for key := range f {
				k = append(k, key)
			}
			return k, nil
		},
		Get: func(key string) (json.RawMessage, error) {
			if v, ok := f[key]; ok {
				return json.RawMessage(v), nil
			}
			return nil, nil
		},
	}}
}

func run(t *testing.T, r view.Reader, name string, args map[string]any) (any, error) {
	t.Helper()
	for _, tl := range Tools(r) {
		if tl.Name == name {
			return tl.Run(args)
		}
	}
	t.Fatalf("no tool %s", name)
	return nil, nil
}

const (
	withFP2  = `{"v":3,"fp":"a1","fp2":"b2","manifest":"m1","inputs2":{"tree":"t1","bases":["x"]},"repository":"novox/r","commit":"c1","path":".","toolchains":{"go":{"version":"go1.27.1","recipe":"2"}}}`
	withNone = `{"v":3,"none":"no successful trunk build recorded its inputs","none2":"builder's fingerprint not yet known","repository":"novox/r","commit":"c2","path":"modules/b"}`
)

// 1562/AC1: indexer_module answers the key's value as stored: FP, FP2, None2, Inputs2, Path and Toolchains are all there.
func TestModuleToolAnswersTheStoredValue(t *testing.T) {
	r := fake{"a": withFP2, "b": withNone}.reader()
	for key, want := range map[string]string{"a": withFP2, "b": withNone} {
		out, err := run(t, r, view.ModuleReadTool, map[string]any{"module": key})
		if err != nil {
			t.Fatal(err)
		}
		if got := string(out.(json.RawMessage)); got != want {
			t.Errorf("%s = %s, want %s", key, got, want)
		}
	}
	out, _ := run(t, r, view.ModuleReadTool, map[string]any{"module": "a"})
	var m map[string]any
	if err := json.Unmarshal(out.(json.RawMessage), &m); err != nil || m["fp"] != "a1" || m["fp2"] != "b2" || m["path"] != "." || m["inputs2"] == nil || m["toolchains"] == nil {
		t.Errorf("stored fields are not all there: %v %v", m, err)
	}
}

// A module with no key, and a name that is no key, are said so.
func TestModuleToolRefusesWhatIsNotThere(t *testing.T) {
	r := fake{"a": withFP2}.reader()
	if _, err := run(t, r, view.ModuleReadTool, map[string]any{"module": "gone"}); err == nil || !strings.Contains(err.Error(), "no module gone") {
		t.Errorf("a missing module: %v", err)
	}
	if _, err := run(t, r, view.ModuleReadTool, map[string]any{"module": ""}); err == nil {
		t.Errorf("an empty name was answered")
	}
}

// 1562/AC1: indexer_modules answers every key as stored, and with none2 only those that say why they have no FP2.
func TestModulesToolAnswersEveryKeyAsStored(t *testing.T) {
	r := fake{"a": withFP2, "b": withNone}.reader()
	out, err := run(t, r, view.ModulesReadTool, map[string]any{})
	if err != nil {
		t.Fatal(err)
	}
	all := out.(map[string]any)["modules"].(map[string]json.RawMessage)
	if len(all) != 2 || string(all["a"]) != withFP2 || string(all["b"]) != withNone {
		t.Errorf("modules = %v", all)
	}
	out, err = run(t, r, view.ModulesReadTool, map[string]any{"none2": true})
	if err != nil {
		t.Fatal(err)
	}
	only := out.(map[string]any)["modules"].(map[string]json.RawMessage)
	if len(only) != 1 || string(only["b"]) != withNone {
		t.Errorf("none2 modules = %v", only)
	}
}

const (
	fp2A      = "src2:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	fp2B      = "src2:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
	keyA      = "netcheck.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	keyB      = "zsh.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
	doneBuild = `{"v":1,"state":"done","by":"novox.mesh-delivery-builder","step":"built on shanks, ace","manifest":"m","artifacts":[{"name":"program","kind":"bundle","digest":"sha256:d1"}]}`
	failBuild = `{"v":1,"state":"failed","by":"novox.mesh-delivery-builder","error":"refused kind: package"}`
)

func both(builds, modules fake) view.Reader {
	r := modules.reader()
	r.Builds = builds.reader().State
	return r
}

// 1723/AC1: builder_builds lists every key as stored (module, fingerprint, state, digests, error), and narrows by module and state.
func TestBuilderBuildsListsKeysAsStored(t *testing.T) {
	r := both(fake{keyA: doneBuild, keyB: failBuild, "junk": "{}"}, fake{})
	out, err := run(t, r, view.BuilderBuildsReadTool, map[string]any{})
	if err != nil {
		t.Fatal(err)
	}
	rows := out.(map[string]any)["builds"].([]view.BuilderRow)
	if len(rows) != 2 || rows[0].Key != keyA || rows[0].Module != "netcheck" || rows[0].Fingerprint != fp2A || string(rows[0].Build) != doneBuild || string(rows[1].Build) != failBuild {
		t.Errorf("rows = %+v", rows)
	}
	for args, want := range map[string]string{"state": keyB, "module": keyA} {
		out, _ := run(t, r, view.BuilderBuildsReadTool, map[string]any{args: map[string]string{keyB: "failed", keyA: "netcheck"}[want]})
		got := out.(map[string]any)["builds"].([]view.BuilderRow)
		if len(got) != 1 || got[0].Key != want {
			t.Errorf("%s filter = %+v, want %s", args, got, want)
		}
	}
}

// 1723/AC2: builder_build answers one key by module and fp2, and by module alone through the indexer's fp2 (joined at its commit).
func TestBuilderBuildJoinsTheIndexersFingerprint(t *testing.T) {
	idx := `{"v":3,"fp2":"` + fp2A + `","commit":"c1","path":"."}`
	r := both(fake{keyA: doneBuild}, fake{"netcheck": idx, "zsh": `{"v":3,"none2":"not known","commit":"c9"}`})
	for _, args := range []map[string]any{{"module": "netcheck", "fp2": fp2A}, {"module": "netcheck"}, {"module": "netcheck", "commit": "c1"}} {
		out, err := run(t, r, view.BuilderBuildReadTool, args)
		if err != nil {
			t.Fatalf("%v: %v", args, err)
		}
		if row := out.(view.BuilderRow); row.Key != keyA || string(row.Build) != doneBuild {
			t.Errorf("%v = %+v", args, row)
		}
	}
	for args, want := range map[string]string{"netcheck/c2": "not c2", "zsh": "not known", "gone": "no module gone"} {
		a := map[string]any{"module": strings.Split(args, "/")[0]}
		if strings.Contains(args, "/") {
			a["commit"] = "c2"
		}
		if _, err := run(t, r, view.BuilderBuildReadTool, a); err == nil || !strings.Contains(err.Error(), want) {
			t.Errorf("%v: err = %v, want %q", a, err, want)
		}
	}
	if _, err := run(t, r, view.BuilderBuildReadTool, map[string]any{"module": "netcheck", "fp2": fp2B}); err == nil || !strings.Contains(err.Error(), "holds no build") {
		t.Errorf("an unbuilt fingerprint: %v", err)
	}
}