mesh-delivery/modules/mesh-delivery-forge-bridge/internal/bridge/files_test.go

package bridge

import (
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"os"
	"reflect"
	"strings"
	"testing"

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

// The bytes the forge answers in these tests are two real files of this repository, read from the working tree: the
// module.json and the go.sum of modules/mesh-delivery-forge-bridge (two directories up). The forge's own answer shape
// is mesh-catalog modules/gitea tools/index.ts gitea_get_file; the bridge sees only the bytes (issue 1448).
func real(t *testing.T, name string) []byte {
	t.Helper()
	b, err := os.ReadFile("../../" + name)
	if err != nil {
		t.Fatal(err)
	}
	return b
}

func hexSum(b []byte) string { s := sha256.Sum256(b); return hex.EncodeToString(s[:]) }

type fileCall struct{ owner, repo, path, ref string }

// forgeFiles answers as the forge does for a path: its bytes, ErrNotFound for a path in none, the error in errs.
type forgeFiles struct {
	have  map[string][]byte
	errs  map[string]error
	calls []fileCall
}

func (f *forgeFiles) get(owner, repo, path, ref string) ([]byte, error) {
	f.calls = append(f.calls, fileCall{owner, repo, path, ref})
	if err, ok := f.errs[path]; ok {
		return nil, err
	}
	if b, ok := f.have[path]; ok {
		return b, nil
	}
	return nil, ErrNotFound
}

// anyFiles is a forge that has a module.json at every path and no lock file, for tests that are not about the files.
func anyFiles(owner, repo, path, ref string) ([]byte, error) {
	if strings.HasSuffix(path, "module.json") {
		return []byte("{}"), nil
	}
	return nil, ErrNotFound
}

func TestMergedCarriesManifestsAndLocks(t *testing.T) { // 1448/AC1
	manifest, sum := real(t, "module.json"), real(t, "go.sum")
	forge := &forgeFiles{have: map[string][]byte{"modules/a/module.json": manifest, "modules/a/go.sum": sum, "modules/b/module.json": []byte(`{"module":"b"}`)}}
	var calls []call
	msg, err := Convert(mergedSubject, mergedBody(nil), treesOf(&calls, "r0", map[string]string{"modules/a": "t1", "modules/b": "t2"}, nil), forge.get)
	if err != nil {
		t.Fatal(err)
	}
	f, err := delivery.DecodeForge(msg.Data)
	if err != nil {
		t.Fatal(err)
	}
	if want := map[string]string{"modules/a": string(manifest), "modules/b": `{"module":"b"}`}; !reflect.DeepEqual(f.Manifests, want) {
		t.Errorf("manifests = %v", f.Manifests)
	}
	if want := map[string]map[string]string{"modules/a": {"go.sum": hexSum(sum)}}; !reflect.DeepEqual(f.Locks, want) {
		t.Errorf("locks = %v, want %v", f.Locks, want)
	}
}

func TestPullWithKnownDirsCarriesTheSameAtTheHead(t *testing.T) { // 1448/AC2
	manifest := real(t, "module.json")
	forge := &forgeFiles{have: map[string][]byte{"modules/a/module.json": manifest}}
	msg, err := Convert(updatedSubject, updated(nil), nil, forge.get)
	if err != nil {
		t.Fatal(err)
	}
	f, _ := delivery.DecodeForge(msg.Data)
	if !reflect.DeepEqual(f.Manifests, map[string]string{"modules/a": string(manifest)}) || len(f.Locks) != 0 {
		t.Errorf("manifests %v locks %v", f.Manifests, f.Locks)
	}
	if len(forge.calls) == 0 || forge.calls[0].ref != head {
		t.Errorf("calls %v, want the head %s", forge.calls, head)
	}
	// Dirs not known: neither field, and the forge is not asked.
	forge = &forgeFiles{}
	msg, err = Convert(updatedSubject, updated(map[string]any{"module_dirs": nil, "module_dirs_said": nil}), nil, forge.get)
	if err != nil {
		t.Fatal(err)
	}
	f, _ = delivery.DecodeForge(msg.Data)
	if f.Manifests != nil || f.Locks != nil || len(forge.calls) != 0 {
		t.Errorf("manifests %v locks %v calls %v", f.Manifests, f.Locks, forge.calls)
	}
}

func TestAForgeErrorOrAMissingManifestIsRetryAndALockNotFoundIsLeftOut(t *testing.T) { // 1448/AC3
	boom := errors.New("Gitea API /repos/novox/mesh-delivery/contents/modules/a/go.sum?ref=x: 502 bad gateway")
	trees := func() Trees { var c []call; return treesOf(&c, "r0", map[string]string{"modules/a": "t1"}, nil) }
	for name, forge := range map[string]*forgeFiles{
		"a manifest error":     {errs: map[string]error{"modules/a/module.json": boom}},
		"a manifest not found": {},
		"a lock file error":    {have: map[string][]byte{"modules/a/module.json": []byte("{}")}, errs: map[string]error{"modules/a/go.sum": boom}},
		"a second lock error":  {have: map[string][]byte{"modules/a/module.json": []byte("{}")}, errs: map[string]error{"modules/a/package-lock.json": boom}},
	} {
		msg, err := Convert(mergedSubject, mergedBody(nil), trees(), forge.get)
		if !errors.Is(err, ErrRetry) || msg.Data != nil {
			t.Errorf("%s: err = %v data = %s, want ErrRetry and no message", name, err, msg.Data)
		}
		_, err = Convert(updatedSubject, updated(nil), nil, forge.get)
		if !errors.Is(err, ErrRetry) {
			t.Errorf("%s (pull): err = %v, want ErrRetry", name, err)
		}
	}
	forge := &forgeFiles{have: map[string][]byte{"modules/a/module.json": []byte("{}")}}
	msg, err := Convert(mergedSubject, mergedBody(nil), trees(), forge.get)
	if err != nil {
		t.Fatal(err)
	}
	if f, _ := delivery.DecodeForge(msg.Data); f.Locks != nil {
		t.Errorf("locks = %v, want none for lock files the forge does not have", f.Locks)
	}
}

func TestTheFilesAreAskedAtTheMergeCommitByOwnerRepoPathAndRef(t *testing.T) { // 1448/AC4 (the call's arguments; the manifest is in manifest_test)
	forge := &forgeFiles{have: map[string][]byte{"modules/a/module.json": []byte("{}")}}
	var calls []call
	if _, err := Convert(mergedSubject, mergedBody(nil), treesOf(&calls, "r0", map[string]string{"modules/a": "t1"}, nil), forge.get); err != nil {
		t.Fatal(err)
	}
	want := []fileCall{{"novox", "mesh-delivery", "modules/a/module.json", merge}, {"novox", "mesh-delivery", "modules/a/go.sum", merge},
		{"novox", "mesh-delivery", "modules/a/package-lock.json", merge}}
	if !reflect.DeepEqual(forge.calls, want) {
		t.Errorf("calls = %v, want %v", forge.calls, want)
	}
}