288 lines
10 KiB
Go
288 lines
10 KiB
Go
package main
|
|
|
|
// i3's shape (novox/hq ADR 0208): it holds node-display-session and requires the X display on its own
|
|
// machine; it contributes the session's exec to the last xinitrc slot and the desktop's identity to
|
|
// the environment; it owns the main configuration, which ends by including the drop-in directory, and
|
|
// the login manager's session entry, which runs the session's start.
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
type manifest struct {
|
|
Capabilities []string `json:"capabilities"`
|
|
Requires []string `json:"requires"`
|
|
Claims []struct {
|
|
Name string `json:"name"`
|
|
Scope string `json:"scope"`
|
|
Serves []string `json:"serves"`
|
|
} `json:"claims"`
|
|
Seats any `json:"seats"`
|
|
Tools []string
|
|
Environment struct {
|
|
Variables map[string]string `json:"variables"`
|
|
} `json:"environment"`
|
|
Items []struct {
|
|
Collection string `json:"collection"`
|
|
Attributes map[string]string `json:"attributes"`
|
|
Template string `json:"template"`
|
|
} `json:"items"`
|
|
Shell []struct {
|
|
For, Slot, Code string
|
|
} `json:"shell"`
|
|
Resources []map[string]any `json:"resources"`
|
|
Build struct {
|
|
Artifacts []map[string]any `json:"artifacts"`
|
|
} `json:"build"`
|
|
}
|
|
|
|
func readManifest(t *testing.T) manifest {
|
|
raw, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var m manifest
|
|
if err := json.Unmarshal(raw, &m); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// The module's code and variables are the templates of its items (design 57 L3, issues 795 and 807).
|
|
for _, it := range m.Items {
|
|
text, err := os.ReadFile(filepath.Join("..", "..", it.Template))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
parts := strings.Split(it.Collection, ":")
|
|
switch {
|
|
case len(parts) == 3 && parts[0] == "shell":
|
|
m.Shell = append(m.Shell, struct{ For, Slot, Code string }{parts[1], parts[2], string(text)})
|
|
case it.Collection == "environment" && it.Attributes["kind"] == "variable":
|
|
if m.Environment.Variables == nil {
|
|
m.Environment.Variables = map[string]string{}
|
|
}
|
|
m.Environment.Variables[it.Attributes["name"]] = strings.TrimSuffix(string(text), "\n")
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
|
|
func resource(t *testing.T, m manifest, id string) map[string]any {
|
|
for _, r := range m.Resources {
|
|
if r["id"] == id {
|
|
return r
|
|
}
|
|
}
|
|
t.Fatalf("no resource %s", id)
|
|
return nil
|
|
}
|
|
|
|
func TestItHoldsTheSessionSeatOnAMachineWithAnXDisplay(t *testing.T) {
|
|
m := readManifest(t)
|
|
if m.Seats != nil || len(m.Claims) != 1 || m.Claims[0].Name != "node-display-session" || strings.Join(m.Claims[0].Serves, ",") != "reload,workspaces,windows" {
|
|
t.Fatalf("%+v", m.Claims)
|
|
}
|
|
if strings.Join(m.Requires, ",") != "x11-display" {
|
|
t.Fatalf("requires %v", m.Requires)
|
|
}
|
|
served := map[string]bool{}
|
|
for _, tool := range tools(&i3{}) {
|
|
served[tool.Name] = true
|
|
}
|
|
for _, v := range m.Claims[0].Serves {
|
|
if !served["node-display-session."+v] {
|
|
t.Errorf("the seat's %s is not served", v)
|
|
}
|
|
}
|
|
if len(served) != len(m.Tools)+3 {
|
|
t.Fatalf("served %d, listed %d", len(served), len(m.Tools))
|
|
}
|
|
for _, n := range m.Tools {
|
|
if !served[n] || !strings.HasPrefix(n, "i3_") {
|
|
t.Errorf("%s", n)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestItContributesTheSessionsExecLastAndTheDesktopsIdentity(t *testing.T) {
|
|
m := readManifest(t)
|
|
if len(m.Shell) != 1 || m.Shell[0].For != "xinitrc" || m.Shell[0].Slot != "last" {
|
|
t.Fatalf("%+v", m.Shell)
|
|
}
|
|
var code []string
|
|
for _, l := range strings.Split(strings.TrimSpace(m.Shell[0].Code), "\n") {
|
|
if !strings.HasPrefix(l, "#") {
|
|
code = append(code, l)
|
|
}
|
|
}
|
|
if len(code) != 1 || !strings.HasPrefix(code[0], "exec i3") {
|
|
t.Fatalf("one line, the exec: %q", code)
|
|
}
|
|
if v := m.Environment.Variables; len(v) != 2 || v["XDG_CURRENT_DESKTOP"] != "i3" || v["XDG_SESSION_DESKTOP"] != "i3" {
|
|
t.Fatalf("%v", v)
|
|
}
|
|
}
|
|
|
|
func TestTheConfigurationIsTheModulesFileImprovedAndEndsWithTheDropIns(t *testing.T) {
|
|
m := readManifest(t)
|
|
r := resource(t, m, "config")
|
|
raw, _ := os.ReadFile(filepath.Join("..", "..", "files", "config"))
|
|
if _, inline := r["content"]; inline || r["template"] != "files/config" || len(raw) == 0 ||
|
|
r["path"] != "${machine:account-home}/.config/i3/config" || r["into"] != nil {
|
|
t.Fatal("the manifest takes files/config whole as its template, as an owned file")
|
|
}
|
|
c := string(raw)
|
|
lines := strings.Split(strings.TrimSpace(c), "\n")
|
|
if lines[len(lines)-1] != "include ~/.config/i3/config.d/*.conf" {
|
|
t.Fatal("the drop-ins are read last, with every variable in scope")
|
|
}
|
|
var lines2 []string
|
|
for _, l := range lines {
|
|
if !strings.HasPrefix(strings.TrimSpace(l), "#") {
|
|
lines2 = append(lines2, l)
|
|
}
|
|
}
|
|
code := strings.Join(lines2, "\n")
|
|
for _, gone := range []string{"lxpolkit", "xdg-desktop-portal", "xrdb", "Hack Nerd Font", "refresh_i3status", "rice_set", "exec xterm",
|
|
"exec --no-startup-id picom", "exec --no-startup-id nm-applet", "exec --no-startup-id blueman-applet", "exec --no-startup-id nextcloud", "hal/",
|
|
// carried by their own modules' drop-ins: rofi, clipmenu, feh, i3status-rust, gnome-keyring
|
|
"rofi", "greenclip", "$mod+period", "powermenu", "theme-picker", ".fehbg", "bar {", "i3status-rs", "unlock-keyring",
|
|
// the peripherals' tray: polychromatic's contribution
|
|
"polychromatic"} {
|
|
if strings.Contains(code, gone) {
|
|
t.Errorf("the configuration still holds %q", gone)
|
|
}
|
|
}
|
|
if !strings.Contains(c, "\nfont pango:JetBrainsMono Nerd Font 11\n") || !strings.Contains(c, "exec --no-startup-id dex --autostart --environment i3") {
|
|
t.Fatal("the chosen face for titles; XDG autostart through dex")
|
|
}
|
|
if !strings.Contains(c, "bindsym $mod+Delete exec --no-startup-id loginctl lock-session") {
|
|
t.Fatal("the lock key goes through logind, which the lock screen's module relies on")
|
|
}
|
|
if i3, err := exec.LookPath("i3"); err == nil {
|
|
// As a node with no contribution and no file of the operator's would hold it.
|
|
alone := strings.Replace(strings.Replace(c, "${contribution:node-display-session:config}", "", 1),
|
|
"\ninclude ~/.config/i3/config.d/*.conf", "\n", 1)
|
|
path := filepath.Join(t.TempDir(), "config")
|
|
os.WriteFile(path, []byte(alone), 0o644)
|
|
out, err := exec.Command(i3, "-C", "-c", path).CombinedOutput()
|
|
if err != nil || len(ParseCheck(string(out))) > 0 {
|
|
t.Fatalf("i3 -C: %v %s", err, out)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTheLoginManagersEntryRunsTheSessionsStart(t *testing.T) {
|
|
m := readManifest(t)
|
|
r := resource(t, m, "session")
|
|
if r["path"] != "/etc/lemurs/wms/i3" || r["mode"] != "0755" {
|
|
t.Fatalf("%v", r)
|
|
}
|
|
if r["template"] != "files/wms/i3" {
|
|
t.Fatalf("the entry's text is not its template files/wms/i3: %v", r["template"])
|
|
}
|
|
entry, _ := os.ReadFile(filepath.Join("..", "..", "files", "wms", "i3"))
|
|
if !strings.Contains(string(entry), `exec systemd-cat -t x-session /bin/sh "$HOME/.xinitrc"`) {
|
|
t.Fatal("the entry runs the session's start, never i3 bare")
|
|
}
|
|
pkgs := map[string]bool{}
|
|
for _, x := range m.Resources {
|
|
if x["type"] == "package" {
|
|
pkgs[x["package"].(string)] = true
|
|
}
|
|
}
|
|
if !pkgs["i3-wm"] || !pkgs["dex"] || len(pkgs) != 2 {
|
|
t.Fatalf("%v", pkgs)
|
|
}
|
|
a := m.Build.Artifacts[0]
|
|
if a["from"] != "cmd/i3-tools" || a["binary"] != "i3-tools" || a["language"] != "go" {
|
|
t.Fatalf("a binary not named i3, so nothing that looks for i3 by name finds the tools: %v", a)
|
|
}
|
|
}
|
|
|
|
// Every module of the catalogue that contributes window-manager lines (novox/hq ADR 0212) is placed in
|
|
// the main file as the controller places them — in module order, each module's under a line naming it
|
|
// — and loaded as i3 would load them on a machine with all of them assigned: no two bind one key, and
|
|
// every line parses.
|
|
func TestTheMainFileAndEveryModulesContributionLoadTogether(t *testing.T) {
|
|
i3, err := exec.LookPath("i3")
|
|
if err != nil {
|
|
t.Skip("no i3 here to check with")
|
|
}
|
|
dir := t.TempDir()
|
|
manifests, _ := filepath.Glob(filepath.Join("..", "..", "..", "*", "module.json"))
|
|
sort.Strings(manifests)
|
|
var placed strings.Builder
|
|
var found []string
|
|
for _, p := range manifests {
|
|
raw, _ := os.ReadFile(p)
|
|
var m struct {
|
|
Module string `json:"module"`
|
|
Contributions []struct {
|
|
Seat, Kind, Content string
|
|
} `json:"contributions"`
|
|
}
|
|
json.Unmarshal(raw, &m)
|
|
named := false
|
|
for _, c := range m.Contributions {
|
|
if c.Seat != "node-display-session" || c.Kind != "config" {
|
|
continue
|
|
}
|
|
if !named {
|
|
placed.WriteString("# " + m.Module + "\n")
|
|
named = true
|
|
found = append(found, m.Module)
|
|
}
|
|
placed.WriteString(c.Content)
|
|
if !strings.HasSuffix(c.Content, "\n") {
|
|
placed.WriteString("\n")
|
|
}
|
|
}
|
|
}
|
|
if len(found) < 5 {
|
|
t.Fatalf("expected the launcher, clipboard, wallpaper, bars and the laptop to contribute; found %v", found)
|
|
}
|
|
main, _ := os.ReadFile(filepath.Join("..", "..", "files", "config"))
|
|
text := strings.Replace(string(main), "${contribution:node-display-session:config}", placed.String(), 1)
|
|
// The operator's own files are not the catalogue's: the include line itself goes (a contribution may
|
|
// name it in a comment, so only the line that is exactly it).
|
|
text = strings.Replace(text, "\ninclude ~/.config/i3/config.d/*.conf", "\n", 1)
|
|
os.WriteFile(filepath.Join(dir, "config"), []byte(text), 0o644)
|
|
out, err := exec.Command(i3, "-C", "-c", filepath.Join(dir, "config")).CombinedOutput()
|
|
if err != nil || len(ParseCheck(string(out))) > 0 {
|
|
t.Fatalf("with the contributions of %v: %v\n%s", found, err, out)
|
|
}
|
|
}
|
|
|
|
// No file resource carries its text inline: each names its template in files/, and the build packs files/
|
|
// into the one archive the controller reads the templates back from (novox/hq ADR 0349 §2).
|
|
func TestEveryFileTakesItsTextFromATemplate(t *testing.T) {
|
|
m := readManifest(t)
|
|
for _, r := range m.Resources {
|
|
if _, inline := r["content"]; inline {
|
|
t.Errorf("resource %v keeps its text inline: keep it in files/ and name it as the template", r["id"])
|
|
}
|
|
if name, ok := r["template"].(string); ok {
|
|
if _, err := os.Stat(filepath.Join("..", "..", name)); err != nil {
|
|
t.Errorf("resource %v names %s: %v", r["id"], name, err)
|
|
}
|
|
}
|
|
}
|
|
packs := 0
|
|
for _, a := range m.Build.Artifacts {
|
|
if a["kind"] == "archive" && a["from"] == "files" {
|
|
packs++
|
|
if a["name"] != "files" {
|
|
t.Errorf("the templates archive is named %v, not files", a["name"])
|
|
}
|
|
}
|
|
}
|
|
if packs != 1 {
|
|
t.Errorf("the build packs files/ into %d archives, not one", packs)
|
|
}
|
|
}
|