mesh-catalog/modules/power/cmd/power/templates_test.go

package main

import (
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

// Each file's text is a template in templates/, the directory the manifest names (novox/hq ADR 0349 §2, issue 731),
// never in files/: files/ is the archive the machine unpacks, and stays exactly what the machine is given.
func TestEveryFileTakesItsTextFromATemplateOutsideTheUnpackedFiles(t *testing.T) {
	raw, err := os.ReadFile("../../module.json")
	if err != nil {
		t.Fatal(err)
	}
	var m struct {
		Templates string           `json:"templates"`
		Resources []map[string]any `json:"resources"`
		Build     struct {
			Artifacts []map[string]any `json:"artifacts"`
		} `json:"build"`
	}
	if err := json.Unmarshal(raw, &m); err != nil {
		t.Fatal(err)
	}
	if m.Templates != "templates" {
		t.Fatalf("the manifest names the templates directory %q, not templates", m.Templates)
	}
	files := 0
	for _, r := range m.Resources {
		if _, inline := r["content"]; inline {
			t.Errorf("resource %v keeps its text inline: keep it in templates/ and name it as the template", r["id"])
		}
		if r["type"] != "file" {
			continue
		}
		files++
		name, _ := r["template"].(string)
		if !strings.HasPrefix(name, "templates/") {
			t.Errorf("resource %v names the template %q, not one in templates/", r["id"], name)
			continue
		}
		if st, err := os.Lstat(filepath.Join("../..", name)); err != nil || !st.Mode().IsRegular() {
			t.Errorf("resource %v names the template %s, which is not a plain file: %v", r["id"], name, err)
		}
	}
	if files == 0 {
		t.Fatal("no file resource")
	}
	packs := 0
	for _, a := range m.Build.Artifacts {
		if a["kind"] == "archive" && a["from"] == "templates" {
			packs++
			if a["name"] != "templates" {
				t.Errorf("the templates archive is named %v, not templates", a["name"])
			}
		}
	}
	if packs != 1 {
		t.Fatalf("the build packs templates/ into %d archives, not one", packs)
	}
	// The templates archive is read by the controller, never unpacked onto the machine.
	for _, r := range m.Resources {
		if r["artifact"] == "templates" {
			t.Errorf("resource %v places the templates archive on the machine", r["id"])
		}
	}
	// And files/ holds what the machine runs, no template.
	err = filepath.WalkDir("../../files", func(at string, d os.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.IsDir() && !strings.HasPrefix(filepath.ToSlash(at), "../../files/bin/") {
			t.Errorf("files/ holds %s, which is not one of the scripts the machine unpacks", at)
		}
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
}

// The bar's blocks are two items of the collection the bar places (design 57 L3, issue 781): the text i3status-rust's
// bars hold for the battery and for the power draw, byte for byte as the bar's own template rendered them before, the
// draw's key being the machine's own name.
func TestTheBarBlocksAreTwoItemsOfTheBarsCollection(t *testing.T) {
	raw, err := os.ReadFile("../../module.json")
	if err != nil {
		t.Fatal(err)
	}
	var m struct {
		Contributions []any `json:"contributions"`
		Items         []struct {
			Collection   string            `json:"collection"`
			Name         string            `json:"name"`
			IfCapability string            `json:"if-capability"`
			Attributes   map[string]string `json:"attributes"`
			Template     string            `json:"template"`
		} `json:"items"`
	}
	if err := json.Unmarshal(raw, &m); err != nil {
		t.Fatal(err)
	}
	if len(m.Contributions) != 0 || len(m.Items) != 2 {
		t.Fatalf("%d contributions and %d items", len(m.Contributions), len(m.Items))
	}
	want := []struct{ name, capability, order, template, text string }{
		{"battery", "battery", "40", "templates/bar-battery", "[[block]]\nblock = \"battery\"\n" +
			"format = \"$icon $percentage{ $time|}\"\ncharging_format = \"$icon $percentage{ $time|}\"\n" +
			"not_charging_format = \"$icon $percentage\"\nfull_format = \"$icon $percentage\"\n" +
			"empty_format = \"$icon $percentage\"\nmissing_format = \"\"\n\n"},
		{"power-draw", "power-meter", "45", "templates/bar-power-draw", "[[block]]\nblock = \"custom\"\n" +
			"command = \"~/.local/bin/i3status-value power.draw ${machine:name}\"\ninterval = 5\nhide_when_empty = true\n\n"},
	}
	for i, w := range want {
		it := m.Items[i]
		if it.Collection != "contribution:node-bar:block" || it.Name != w.name || it.IfCapability != w.capability ||
			it.Template != w.template || it.Attributes["bar"] != "bottom" || it.Attributes["place"] != "status" ||
			it.Attributes["order"] != w.order || len(it.Attributes) != 3 {
			t.Errorf("item %d is %+v", i, it)
		}
		text, err := os.ReadFile(filepath.Join("../..", w.template))
		if err != nil || string(text) != w.text {
			t.Errorf("%s holds %q (%v), want %q", w.template, text, err, w.text)
		}
	}
}

// A shutdown is bounded at ten minutes, not systemd's thirty (issue 1126, ace's reboot of 2026-10-28): every unit had
// stopped within 17 s, yet the bus and the authorization manager were started again during the shutdown, nothing
// stopped them a second time, and the reboot waited on its job's own timeout of 30 min with nothing on the console.
// The bound keeps each target's own forcing action (reboot-force and the like): systemd's last phase still ends
// every process, unmounts and syncs. Ten minutes stays above the longest stop the catalogue declares (120 s) chained.
func TestEveryShutdownIsBoundedAtTenMinutes(t *testing.T) {
	raw, err := os.ReadFile("../../module.json")
	if err != nil {
		t.Fatal(err)
	}
	var m struct {
		Resources []map[string]any `json:"resources"`
	}
	if err := json.Unmarshal(raw, &m); err != nil {
		t.Fatal(err)
	}
	byPath := map[string]map[string]any{}
	for _, r := range m.Resources {
		if p, ok := r["path"].(string); ok {
			byPath[p] = r
		}
	}
	for _, target := range []string{"reboot", "poweroff", "halt"} {
		dir := "/etc/systemd/system/" + target + ".target.d"
		if d := byPath[dir]; d == nil || d["type"] != "directory" || d["unknown"] != "program" {
			t.Errorf("%s: no directory resource %s whose unknown files are the program's: %v", target, dir, d)
		}
		f := byPath[dir+"/mesh-power.conf"]
		if f == nil || f["type"] != "file" {
			t.Errorf("%s: no file resource %s/mesh-power.conf", target, dir)
			continue
		}
		name, _ := f["template"].(string)
		text, err := os.ReadFile(filepath.Join("../..", name))
		if err != nil {
			t.Errorf("%s: %v", target, err)
			continue
		}
		var lines []string
		for _, l := range strings.Split(string(text), "\n") {
			if l != "" && !strings.HasPrefix(l, "#") {
				lines = append(lines, l)
			}
		}
		if strings.Join(lines, "\n") != "[Unit]\nJobTimeoutSec=10min" {
			t.Errorf("%s: %s sets %q, want only [Unit] JobTimeoutSec=10min (the target keeps its own action)", target, name, lines)
		}
	}
}