mesh-catalog/modules/betterbird/cmd/betterbird-tools/manifest_test.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"testing"
)

// betterbird's shape (novox/hq issue 345, ADR 0208, ADR 0316): the X display on its own machine; its directory
// in the home with the user.js the setting prefs fills and the accounts file the setting accounts fills, both
// trusted; the community package declared absent before anything is placed in /opt/betterbird; Betterbird from
// its pinned upstream release, Owl pinned by its vendor's digest, the policy and the dictionaries' default
// unpacked into the installation; the tools' program for the start's preparation, the start and the launcher;
// every new build waiting for the operator's push; and the Go bundle serving exactly the listed tools.

type manifest struct {
	Module    string            `json:"module"`
	Version   string            `json:"version"`
	Upgrade   map[string]string `json:"upgrade"`
	Requires  []string          `json:"requires"`
	Invokes   []string          `json:"invokes"`
	Settings  map[string]any    `json:"settings"`
	Tools     []string          `json:"tools"`
	Resources []map[string]any  `json:"resources"`
	Build     struct {
		Artifacts []map[string]any `json:"artifacts"`
	} `json:"build"`
}

func readManifest(t *testing.T) (manifest, string) {
	t.Helper()
	raw, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
	if err != nil {
		t.Fatal(err)
	}
	dec := json.NewDecoder(strings.NewReader(string(raw)))
	dec.DisallowUnknownFields()
	var m manifest
	if err := dec.Decode(&m); err != nil {
		t.Fatalf("module.json: %v", err)
	}
	return m, string(raw)
}

func resource(t *testing.T, m manifest, id string) map[string]any {
	t.Helper()
	for _, r := range m.Resources {
		if r["id"] == id {
			return r
		}
	}
	t.Fatalf("module.json has no resource %s", id)
	return nil
}

func artifact(t *testing.T, m manifest, name string) map[string]any {
	t.Helper()
	for _, a := range m.Build.Artifacts {
		if a["name"] == name {
			return a
		}
	}
	t.Fatalf("module.json builds no artifact %s", name)
	return nil
}

func TestItPlacesBetterbirdWhereTheCommunityPackageDidAndOnlyAfterItIsGone(t *testing.T) {
	m, raw := readManifest(t)
	if m.Module != "betterbird" || !reflect.DeepEqual(m.Requires, []string{"x11-display"}) {
		t.Fatalf("%+v", m)
	}
	// Every new build waits for a person's push: the switch removes a package and replaces what a running
	// Betterbird has open (ADR 0316 §4).
	if m.Upgrade["policy"] != "record" || strings.TrimSpace(m.Upgrade["why"]) == "" {
		t.Fatalf("the module is marked for a person's approval, with why: %v", m.Upgrade)
	}
	var ids []string
	for _, r := range m.Resources {
		ids = append(ids, r["id"].(string))
	}
	want := "configuration-dir,user-js,accounts,community-package,installation,owl,policies,spelling,preparation,start,launcher"
	if strings.Join(ids, ",") != want {
		t.Fatalf("the resources, in the order the node-engine applies them: %v, want %s", ids, want)
	}
	pkg := resource(t, m, "community-package")
	if pkg["type"] != "package" || pkg["package"] != packageFor || pkg["absent"] != true {
		t.Fatalf("the community package is declared absent (ADR 0180): %v", pkg)
	}
	places := map[string]string{"installation": installDir, "owl": filepath.Dir(owlFile),
		"policies": filepath.Dir(policyFile), "spelling": installDir + "/defaults/pref", "preparation": filepath.Dir(preparation)}
	arts := map[string]string{"installation": "archive", "owl": "owl", "policies": "distribution", "spelling": "defaults", "preparation": "tools"}
	for id, path := range places {
		r := resource(t, m, id)
		if r["type"] != "archive" || r["path"] != path || r["artifact"] != arts[id] || r["owner"] != nil {
			t.Errorf("%s is the %s archive unpacked at %s, root's: %v", id, arts[id], path, r)
		}
	}
	for _, never := range []string{".thunderbird", "prefs.js", "logins.json", "key4.db"} {
		if strings.Contains(raw, never) {
			t.Errorf("module.json names %q: the profile is Betterbird's", never)
		}
	}
	s := strings.ToLower(raw)
	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "http://", "mediahuis"} {
		if strings.Contains(s, never) {
			t.Errorf("module.json names %q", never)
		}
	}
}

func TestTheUserJSAndTheAccountsAreTrustedFilesOfTheModulesOwn(t *testing.T) {
	m, _ := readManifest(t)
	file := resource(t, m, "user-js")
	content := file["content"].(string)
	if !strings.HasPrefix(content, mark) || !strings.Contains(content, "${setting:prefs}") || file["trusted"] != true {
		t.Fatalf("the user.js begins with the mark, holds the setting, and is trusted (only the terminal or the operator's warrant sets it): %v", file)
	}
	// The default is a comment, so a machine without the setting places a valid, empty user.js.
	def := m.Settings["prefs"].(map[string]any)["default"].(string)
	if err := validUserJS(strings.ReplaceAll(content, "${setting:prefs}", def)); err != nil {
		t.Fatal(err)
	}
	acc := resource(t, m, "accounts")
	if acc["path"] != "${machine:account-home}/"+accountsFile || acc["merge"] != "json" || acc["trusted"] != true ||
		acc["mode"] != "0600" || acc["owner"] != "${machine:account}" {
		t.Fatalf("the setting accounts reaches the machine as a trusted mergeable file of the account's (ADR 0316 §10, §15): %v", acc)
	}
	got, err := parseAccounts([]byte(acc["content"].(string)))
	if err != nil || len(got) != 0 {
		t.Fatalf("its default declares no account: %v %v", got, err)
	}
	if _, declared := m.Settings["accounts"]; declared {
		t.Fatal("accounts is the operator's value and has no default in the definition (ADR 0262)")
	}
}

func TestBothPinsAreAURLAVersionAndASha256AndOwlIsNeverInTheRepository(t *testing.T) {
	m, _ := readManifest(t)
	sha := regexp.MustCompile(`^[0-9a-f]{64}$`)
	for _, name := range []string{"archive", "owl"} {
		a := artifact(t, m, name)
		u, _ := a["url"].(string)
		if a["kind"] != "archive" || !strings.HasPrefix(u, "https://") || !sha.MatchString(fmt.Sprint(a["sha256"])) ||
			strings.TrimSpace(fmt.Sprint(a["version"])) == "" || a["from"] != nil {
			t.Errorf("%s is pinned by URL, version and sha256, and copied from nowhere in the repository: %v", name, a)
		}
	}
	if a := artifact(t, m, "archive"); a["within"] != "betterbird" {
		t.Errorf("the release unpacks into betterbird/, whose content is the installation: %v", a)
	}
	if a := artifact(t, m, "owl"); a["file"] != filepath.Base(owlFile) {
		t.Errorf("Owl's xpi is kept whole as %s: %v", filepath.Base(owlFile), a)
	}
	// Owl's licence forbids copying it to third parties: no xpi anywhere in the module's tree.
	filepath.Walk(filepath.Join("..", ".."), func(p string, info os.FileInfo, err error) error {
		if err == nil && strings.HasSuffix(strings.ToLower(p), ".xpi") {
			t.Errorf("%s is in the repository", p)
		}
		return nil
	})
}

// owlSupports is the range of Betterbird versions each pinned Owl declares in its manifest.json
// (browser_specific_settings.gecko strict_min_version, strict_max_version), read from the vendor's xpi
// when its pin was taken. Moving Owl's pin means reading the new xpi's range into here.
var owlSupports = map[string][2]string{
	"1.5.6.1": {"115.0", "156.*"},
}

// owlAccepts says why a Betterbird version is outside the range an Owl version declares, or nil.
func owlAccepts(owl, betterbird string) error {
	r, known := owlSupports[owl]
	if !known {
		return fmt.Errorf("Owl %s's supported range is not recorded in owlSupports: read it from the xpi's manifest.json", owl)
	}
	major := func(v string) int {
		head, _, _ := strings.Cut(v, ".")
		n, err := strconv.Atoi(head)
		if err != nil {
			return -1
		}
		return n
	}
	b, lo, hi := major(betterbird), major(r[0]), major(r[1])
	if b < 0 || b < lo || b > hi {
		return fmt.Errorf("Betterbird %s is outside the range Owl %s supports (%s to %s): a Betterbird Owl does not support "+
			"waits for Owl's pin to move (novox/hq ADR 0316 §8)", betterbird, owl, r[0], r[1])
	}
	return nil
}

func TestABetterbirdOwlDoesNotSupportIsRefused(t *testing.T) {
	m, _ := readManifest(t)
	owl, bb := fmt.Sprint(artifact(t, m, "owl")["version"]), fmt.Sprint(artifact(t, m, "archive")["version"])
	if err := owlAccepts(owl, bb); err != nil {
		t.Fatal(err)
	}
	for _, outside := range []string{"157.0esr-bb1", "102.15.1esr-bb4"} {
		if err := owlAccepts(owl, outside); err == nil {
			t.Errorf("Betterbird %s was accepted with Owl %s", outside, owl)
		}
	}
	if err := owlAccepts("9.9", bb); err == nil {
		t.Error("an Owl whose range nobody read was accepted")
	}
}

func TestThePolicyTurnsTheUpdaterOffAndInstallsTheMeshsOwlEverywhere(t *testing.T) {
	m, _ := readManifest(t)
	if a := artifact(t, m, "distribution"); a["kind"] != "archive" || a["from"] != "install/distribution" {
		t.Fatalf("%v", a)
	}
	raw, err := os.ReadFile(filepath.Join("..", "..", "install", "distribution", "policies.json"))
	if err != nil {
		t.Fatal(err)
	}
	if why := policyProblem(raw); why != "" {
		t.Fatalf("the module's policies.json: %s", why)
	}
	entries, _ := os.ReadDir(filepath.Join("..", "..", "install", "distribution"))
	if len(entries) != 1 {
		t.Fatalf("the distribution directory holds the policy alone: %v", entries)
	}
	if a := artifact(t, m, "defaults"); a["kind"] != "archive" || a["from"] != "install/defaults-pref" {
		t.Fatalf("%v", a)
	}
	prefs, err := os.ReadFile(filepath.Join("..", "..", "install", "defaults-pref", "vendor-prefs.js"))
	if err != nil || !strings.Contains(string(prefs), `pref("spellchecker.dictionary_path", "/usr/share/hunspell");`) {
		t.Fatalf("the dictionaries are named as a default, in place of a link: %s %v", prefs, err)
	}
}

func TestTheStartPreparesThenStartsBetterbirdAndTheLauncherUsesIt(t *testing.T) {
	m, _ := readManifest(t)
	start := resource(t, m, "start")
	content := start["content"].(string)
	if start["path"] != "/usr/local/bin/betterbird" || start["mode"] != "0755" ||
		!strings.Contains(content, "\n"+preparation+" prepare ||") || !strings.HasSuffix(content, "\nexec "+startBin+" \"$@\"\n") {
		t.Fatalf("the start runs the preparation, says when it did not complete, and starts Betterbird either way: %v", start)
	}
	launcher := resource(t, m, "launcher")
	lc := launcher["content"].(string)
	if launcher["path"] != "/usr/local/share/applications/eu.betterbird.Betterbird.desktop" ||
		!strings.Contains(lc, "\nExec=/usr/local/bin/betterbird %u\n") || !strings.Contains(lc, "\nIcon="+installDir+"/") ||
		!strings.Contains(lc, "\nStartupWMClass=eu.betterbird.Betterbird\n") {
		t.Fatalf("the launcher starts the module's start and names the icon in the installation: %v", launcher)
	}
	if b := artifact(t, m, "tools"); filepath.Base(preparation) != b["binary"] {
		t.Fatalf("the preparation runs the tools' binary: %v", b)
	}
}

func TestTheToolsAgreeWithTheManifest(t *testing.T) {
	m, _ := readManifest(t)
	served := map[string]bool{}
	for _, tool := range tools() {
		served[tool.Name] = true
		if !strings.HasPrefix(tool.Name, "betterbird_") || strings.TrimSpace(tool.Description) == "" {
			t.Errorf("%s: prefixed betterbird_ and described", tool.Name)
		}
	}
	for _, name := range m.Tools {
		if !served[name] {
			t.Errorf("module.json lists %s, which the bundle does not serve", name)
		}
		delete(served, name)
	}
	for name := range served {
		t.Errorf("the bundle serves %s, which module.json does not list", name)
	}
	b := artifact(t, m, "tools")
	if b["kind"] != "bundle" || b["language"] != "go" || b["from"] != "cmd/betterbird-tools" || b["binary"] != "betterbird-tools" {
		t.Errorf("the Go tools bundle: %v", b)
	}
	// betterbird_accounts proposes the setting accounts through the controller's settings verb (ADR 0317 §9).
	if !reflect.DeepEqual(m.Invokes, []string{"seat:mesh-controller.settings"}) {
		t.Errorf("the module invokes the controller's settings verb and nothing else: %v", m.Invokes)
	}
}