mesh-delivery/modules/mesh-delivery-indexer/internal/index/named_test.go

package index

import (
	"context"
	"errors"
	"reflect"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/delivery"
)

// ADR 0499 clauses 2 and 3 (I7): a module whose every artifact names its paths takes its tree input from them, by mesh-sdk's
// one function, and keeps their objects, so a computation from kept inputs gives the merge's value. The manifest is
// mesh-sdk's module.json at 9cb4d59 (its lib names src, test, package.json, package-lock.json and tsconfig.json).

var sdkObjects = map[string]string{"src": "1111111111111111111111111111111111111111", "test": "2222222222222222222222222222222222222222",
	"package.json": "3333333333333333333333333333333333333333", "package-lock.json": "4444444444444444444444444444444444444444", "tsconfig.json": "5555555555555555555555555555555555555555"}

func TestAModuleNamingItsPathsTakesItsTreeFromThemAndKeepsTheirObjects(t *testing.T) { // I7, ADR 0499 clause 2
	ix, mods, _ := manifestsIndexer(t)
	raw := fixture(t, "sdk-9cb4d59-mesh-sdk")
	f := withManifests(mergedMsg("novox/mesh-sdk", map[string]string{"": "roottree"}), map[string]string{"": raw}, map[string]map[string]string{"": {"package-lock.json": avahiGoSum}})
	f.Paths = map[string]map[string]string{"": sdkObjects}
	if err := ix.Apply(context.Background(), f); err != nil {
		t.Fatal(err)
	}
	m, ok := moduleOf(t, mods, "mesh-sdk")
	if !ok || m.Inputs2 == nil {
		t.Fatalf("module = %+v (%v)", m, ok)
	}
	want, err := delivery.NamedTree(delivery.ManifestDigest([]byte(raw)), sdkObjects)
	if err != nil {
		t.Fatal(err)
	}
	if m.Inputs2.Tree != want || !reflect.DeepEqual(m.Inputs2.Paths, sdkObjects) {
		t.Errorf("inputs = %+v, want the named tree %s and the objects kept", m.Inputs2, want)
	}
	if got := m.ArtifactPaths["lib"]; strings.Join(got, ",") != "src,test,package.json,package-lock.json,tsconfig.json" {
		t.Errorf("artifact paths = %v, want lib's paths as its manifest names them", m.ArtifactPaths)
	}
	// Recomputed from what is kept, with no merge, the module is the same (ADR 0499 clause 2).
	before := string(mods.vals["mesh-sdk"])
	if err := ix.Recompute(context.Background()); err != nil {
		t.Fatal(err)
	}
	if string(mods.vals["mesh-sdk"]) != before {
		t.Errorf("a recompute changed the module: %s, was %s", mods.vals["mesh-sdk"], before)
	}
}

func TestAMessageWithoutTheNamedPathsObjectsGivesTheModuleNoneNamingThem(t *testing.T) { // I7, ADR 0499 clause 3
	ix, mods, _ := manifestsIndexer(t)
	raw := fixture(t, "sdk-9cb4d59-mesh-sdk")
	f := withManifests(mergedMsg("novox/mesh-sdk", map[string]string{"": "roottree"}), map[string]string{"": raw}, nil)
	if err := ix.Apply(context.Background(), f); err != nil {
		t.Fatal(err)
	}
	m, _ := moduleOf(t, mods, "mesh-sdk")
	if m.FP2 != "" || !strings.Contains(m.None2, "named paths") || !strings.Contains(m.None2, "tsconfig.json") {
		t.Errorf("module = %+v, want none naming the paths the message did not carry", m)
	}
}

func TestAModuleNamingNoPathsKeepsItsDirectorysTree(t *testing.T) { // I7, ADR 0499 clause 2: every other module is unchanged
	in := inputsOfNamed("avahi", catalogueManifest(t, "avahi"), "avahitree", map[string]string{"go.sum": avahiGoSum}, map[string]string{"x": "1111111111111111111111111111111111111111"}, noBases)
	if in.Kept == nil || in.Kept.Tree != "avahitree" || in.Kept.Paths != nil {
		t.Errorf("inputs = %+v, want the directory's tree and no paths", in.Kept)
	}
}

func TestACandidatesModuleTakesTheNamedPathsObjectsFromThePreview(t *testing.T) { // I8, ADR 0499 clause 2 (the merge preview)
	ix, _, _ := manifestsIndexer(t)
	raw := fixture(t, "sdk-9cb4d59-mesh-sdk")
	digest, err := ix.keepManifest(context.Background(), "mesh-sdk", raw)
	if err != nil {
		t.Fatal(err)
	}
	named, _ := delivery.NamedTree(digest, sdkObjects)
	with := delivery.Preview{Modules: map[string]delivery.PreviewModule{".": {Tree: named, Manifest: digest, Paths: sdkObjects}}}
	without := delivery.Preview{Modules: map[string]delivery.PreviewModule{".": {Tree: "roottree", Manifest: digest}}}
	if got := ix.candidateModule(context.Background(), "mesh-sdk", ".", without); !strings.Contains(got.None2, "named paths") {
		t.Errorf("without the objects: %+v, want none naming the named paths", got)
	}
	got := ix.candidateModule(context.Background(), "mesh-sdk", ".", with)
	if strings.Contains(got.None2, "named paths") || got.Manifest != digest {
		t.Errorf("with the objects: %+v, want them taken (none only for what else is missing)", got)
	}
	if got.FP2 != "" && !reflect.DeepEqual(got.Paths, sdkObjects) {
		t.Errorf("with a fingerprint: %+v, want the named paths' objects carried for the builder's fetch", got)
	}
}

func TestTheIndexerAsksTheForgeForTheNamedPathsObjectsOfAMerge(t *testing.T) { // I6 as the lead has it: the indexer is the one reader of paths
	ix, mods, _ := manifestsIndexer(t)
	type ask struct {
		repository, sha string
		paths           map[string][]string
	}
	var asked []ask
	ix.Named = func(_ context.Context, repository, sha string, paths map[string][]string) (map[string]map[string]string, error) {
		asked = append(asked, ask{repository, sha, paths})
		return map[string]map[string]string{"": sdkObjects}, nil
	}
	raw := fixture(t, "sdk-9cb4d59-mesh-sdk")
	f := withManifests(mergedMsg("novox/mesh-sdk", map[string]string{"": "roottree", "modules/a": "t"}), map[string]string{"": raw, "modules/a": `{"module":"a","version":"1"}`}, nil)
	if err := ix.Apply(context.Background(), f); err != nil {
		t.Fatal(err)
	}
	if len(asked) != 1 || asked[0].repository != "novox/mesh-sdk" || asked[0].sha != merge || len(asked[0].paths) != 1 ||
		strings.Join(asked[0].paths[""], ",") != "package-lock.json,package.json,src,test,tsconfig.json" {
		t.Fatalf("asked %+v, want the root's named paths of the merge commit, once, and nothing for a module naming none", asked)
	}
	m, _ := moduleOf(t, mods, "mesh-sdk")
	want, _ := delivery.NamedTree(delivery.ManifestDigest([]byte(raw)), sdkObjects)
	if m.Inputs2 == nil || m.Inputs2.Tree != want {
		t.Errorf("module = %+v, want the named tree %s", m, want)
	}
}

func TestAForgeThatCannotSayTheObjectsGivesTheModuleNoneWithItsWords(t *testing.T) { // I6
	ix, mods, _ := manifestsIndexer(t)
	ix.Named = func(context.Context, string, string, map[string][]string) (map[string]map[string]string, error) {
		return nil, errors.New("gitea: the path tsconfig.json of \"\" is not at the commit")
	}
	raw := fixture(t, "sdk-9cb4d59-mesh-sdk")
	if err := ix.Apply(context.Background(), withManifests(mergedMsg("novox/mesh-sdk", map[string]string{"": "roottree"}), map[string]string{"": raw}, nil)); err != nil {
		t.Fatal(err)
	}
	if m, _ := moduleOf(t, mods, "mesh-sdk"); m.FP2 != "" || !strings.Contains(m.None2, "is not at the commit") {
		t.Errorf("module = %+v, want none with the forge's words", m)
	}
}