package main import ( "encoding/json" "os" "os/exec" "path/filepath" "sort" "strings" "testing" ) type manifest struct { Module string `json:"module"` Tools []string `json:"tools"` Emits []string `json:"emits"` Resources []map[string]any `json:"resources"` // Items of collections (novox/hq ADR 0349 clause 13): the vendor keys are an item of the node-hotkeys // triggers, its text the template file beside the manifest. Items []struct { Collection string `json:"collection"` Template string `json:"template"` } `json:"items"` // Old-form contributions to other modules' seats (novox/hq ADR 0212): none is left. Contributions []any `json:"contributions"` } // i3Lines is the module's lines for the window manager: the text of the template of its item of the collection // contribution:node-display-session:config (design 57 L3, issue 848). func (m manifest) i3Lines() string { for _, it := range m.Items { if it.Collection == "contribution:node-display-session:config" { raw, err := os.ReadFile(filepath.Join("..", "..", it.Template)) if err != nil { return "" } return string(raw) } } return "" } // triggers is the module's contribution to node-hotkeys: its vendor keys, the text of the template of its // item of the collection contribution:node-hotkeys:trigger. func (m manifest) triggers() string { for _, it := range m.Items { if it.Collection == "contribution:node-hotkeys:trigger" { raw, err := os.ReadFile(filepath.Join("..", "..", it.Template)) if err != nil { return "" } return string(raw) } } return "" } func readManifest(t *testing.T) manifest { t.Helper() raw, err := os.ReadFile("../../module.json") if err != nil { t.Fatal(err) } var m manifest if err := json.Unmarshal(raw, &m); err != nil { t.Fatal(err) } return m } func TestTheManifestNamesExactlyTheToolsTheBundleServes(t *testing.T) { m := readManifest(t) var served []string for _, tool := range Tools(&Machine{Root: t.TempDir(), Run: newFake(t).run}, nil) { served = append(served, tool.Name) } sort.Strings(served) listed := append([]string(nil), m.Tools...) sort.Strings(listed) if strings.Join(served, ",") != strings.Join(listed, ",") { t.Fatalf("served %v, listed %v", served, listed) } if len(m.Emits) != 1 || m.Emits[0] != "profile.switched" { t.Fatalf("emits %v", m.Emits) } } // The module names the model, never a node, a person or a user id (novox/hq ADR 0112), and every // trigger it names a service restart or reload on is one of its own resources. func TestTheManifestNamesNoMachineAndItsTriggersExist(t *testing.T) { m := readManifest(t) ids := map[string]bool{} for _, r := range m.Resources { ids[r["id"].(string)] = true } raw, _ := os.ReadFile("../../module.json") for _, banned := range []string{"jochen", "/home/", "/run/user/1000", "\"g14\"", "shanks"} { if strings.Contains(string(raw), banned) { t.Errorf("the manifest says %q", banned) } } for _, r := range m.Resources { for _, key := range []string{"restart-on", "reload-on"} { list, _ := r[key].([]any) for _, id := range list { if !ids[id.(string)] { t.Errorf("%s %s names %v, which is not a resource", r["id"], key, id) } } } } } // Every trigger runs a script the module ships, and every script parses. func TestTheVendorKeysRunTheModulesOwnScriptsAndTheyParse(t *testing.T) { m := readManifest(t) triggers := m.triggers() if triggers == "" { t.Fatal("no trigger contribution to node-hotkeys") } for _, line := range strings.Split(triggers, "\n") { f := strings.Split(line, "\t") if strings.HasPrefix(line, "#") || len(f) < 3 { continue } script := strings.Fields(f[2])[0] local := filepath.Join("../../files/bin", filepath.Base(script)) if !strings.HasPrefix(script, "/usr/local/lib/asus-zephyrus-g14/bin/") { t.Errorf("%s runs %s, which the module does not ship", f[0], script) } else if st, err := os.Stat(local); err != nil || st.Mode()&0o111 == 0 { t.Errorf("%s: %s is missing or not executable", f[0], local) } } scripts, _ := filepath.Glob("../../files/bin/*") if len(scripts) == 0 { t.Fatal("no scripts") } // The scripts are bash's. The build seat's Go toolchain carries no bash, so there they are said as // not parsed rather than failed: a missing interpreter is not a broken script. if _, err := exec.LookPath("bash"); err != nil { t.Logf("NOT PARSED: no bash on this machine, so the scripts' syntax was not checked") return } for _, s := range scripts { if out, err := exec.Command("bash", "-n", s).CombinedOutput(); err != nil { t.Errorf("%s: %v %s", s, err, out) } } }