| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254 |
- package modules
- import (
- "encoding/json"
- "errors"
- "net/http"
- "net/http/httptest"
- "net/url"
- "sort"
- "strings"
- "testing"
- )
- // memStore is a StateStore kept in memory
- type memStore struct {
- rows map[string][]byte
- failWrite bool
- }
- func newMemStore() *memStore {
- return &memStore{rows: map[string][]byte{}}
- }
- func (s *memStore) Write(table string, key string, value interface{}) error {
- if s.failWrite {
- return errors.New("disk full")
- }
- js, err := json.Marshal(value)
- if err != nil {
- return err
- }
- s.rows[table+"|"+key] = js
- return nil
- }
- func (s *memStore) Delete(table string, key string) error {
- delete(s.rows, table+"|"+key)
- return nil
- }
- func (s *memStore) ListTable(table string) ([][][]byte, error) {
- keys := []string{}
- for k := range s.rows {
- keys = append(keys, k)
- }
- sort.Strings(keys)
- result := [][][]byte{}
- for _, k := range keys {
- if strings.HasPrefix(k, table+"|") {
- result = append(result, [][]byte{[]byte(strings.TrimPrefix(k, table+"|")), s.rows[k]})
- }
- }
- return result, nil
- }
- func newDisableTestHandler(t *testing.T, store *memStore) *ModuleHandler {
- t.Helper()
- mh := &ModuleHandler{LoadedModule: []*ModuleInfo{}}
- if store != nil {
- if err := mh.LoadDisabledModules(store); err != nil {
- t.Fatalf("LoadDisabledModules: %v", err)
- }
- }
- for _, reg := range []struct{ folder, js string }{
- {"web/Photo", `{"Name":"Photo","Group":"Media","StartDir":"Photo/index.html"}`},
- {"web/Office", `{"Name":"Docs","Group":"Office"}`},
- {"web/Office", `{"Name":"Sheets","Group":"Office"}`},
- {"web/Setup Wizard", `{"Name":"Setup Wizard","Group":"Interface Module"}`},
- {"web/SystemAO", `{"Name":"System Setting","Group":"System Settings"}`},
- {"web/Tools", `{"Name":"Task Manager","Group":"System Tools"}`},
- } {
- if err := mh.RegisterModuleFromAGI(reg.folder, reg.js); err != nil {
- t.Fatalf("RegisterModuleFromAGI: %v", err)
- }
- }
- mh.RegisterModule(ModuleInfo{Name: "Desktop", Group: "Interface Module"})
- return mh
- }
- func moduleNames(list []*ModuleInfo) string {
- names := []string{}
- for _, m := range list {
- names = append(names, m.Name)
- }
- sort.Strings(names)
- return strings.Join(names, ",")
- }
- func TestSetModuleEnabled(t *testing.T) {
- tests := []struct {
- name string
- module string
- enabled bool
- usedBy []string
- wantErr string
- wantDisabled string
- }{
- {name: "disable a normal app", module: "Photo", wantDisabled: "Photo"},
- {name: "disable an interface module nobody boots into", module: "Setup Wizard", wantDisabled: "Setup Wizard"},
- {name: "system settings stay on", module: "System Setting", wantErr: "System modules"},
- {name: "system tools stay on", module: "Task Manager", wantErr: "System modules"},
- {name: "desktop stays on", module: "Desktop", wantErr: "System modules"},
- {name: "interface module still in use", module: "Setup Wizard", usedBy: []string{"administrator"}, wantErr: "administrator group opens this module"},
- {name: "unknown module", module: "Nope", wantErr: "not exists"},
- {name: "enabling an enabled module is a no-op", module: "Photo", enabled: true},
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- mh := newDisableTestHandler(t, newMemStore())
- mh.InterfaceModuleUsers = func(name string) []string {
- if name == tt.module {
- return tt.usedBy
- }
- return nil
- }
- err := mh.SetModuleEnabled(tt.module, tt.enabled)
- if tt.wantErr != "" {
- if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
- t.Fatalf("SetModuleEnabled(%q) error = %v, want %q", tt.module, err, tt.wantErr)
- }
- return
- }
- if err != nil {
- t.Fatalf("SetModuleEnabled(%q) unexpected error: %v", tt.module, err)
- }
- if got := moduleNames(mh.DisabledModule); got != tt.wantDisabled {
- t.Errorf("DisabledModule = %q, want %q", got, tt.wantDisabled)
- }
- if tt.wantDisabled != "" && mh.GetModuleInfoByID(tt.module) != nil {
- t.Errorf("GetModuleInfoByID(%q) still finds a disabled module", tt.module)
- }
- })
- }
- }
- func TestDisabledModuleSurvivesRestart(t *testing.T) {
- store := newMemStore()
- mh := newDisableTestHandler(t, store)
- if err := mh.SetModuleEnabled("Photo", false); err != nil {
- t.Fatalf("disable Photo: %v", err)
- }
- //A fresh handler reading the same store registers Photo as disabled at boot
- restarted := newDisableTestHandler(t, store)
- if restarted.GetModuleInfoByID("Photo") != nil {
- t.Fatal("Photo is loaded again after a restart")
- }
- if !restarted.IsModuleDisabled("photo") {
- t.Error("IsModuleDisabled should ignore case")
- }
- if got := moduleNames(restarted.DisabledModule); got != "Photo" {
- t.Errorf("DisabledModule after restart = %q, want Photo", got)
- }
- if err := restarted.SetModuleEnabled("Photo", true); err != nil {
- t.Fatalf("enable Photo: %v", err)
- }
- if restarted.GetModuleInfoByID("Photo") == nil {
- t.Fatal("Photo is not loaded after enabling it")
- }
- if len(store.rows) != 0 {
- t.Errorf("store still holds %d rows after enabling", len(store.rows))
- }
- //A protected module never registers as disabled, even with a stale row
- store.rows["module|disabled/System Setting"] = []byte("true")
- again := newDisableTestHandler(t, store)
- if again.GetModuleInfoByID("System Setting") == nil {
- t.Error("System Setting was kept off by a stale row")
- }
- }
- func TestSetModuleEnabledStoreFailure(t *testing.T) {
- store := newMemStore()
- mh := newDisableTestHandler(t, store)
- store.failWrite = true
- if err := mh.SetModuleEnabled("Photo", false); err == nil {
- t.Fatal("expected the store error to be returned")
- }
- if mh.GetModuleInfoByID("Photo") == nil || mh.IsModuleDisabled("Photo") {
- t.Error("a module that could not be saved as disabled must stay on")
- }
- }
- func TestIsSourceFolderDisabled(t *testing.T) {
- mh := newDisableTestHandler(t, newMemStore())
- steps := []struct {
- module string
- enabled bool
- folder string
- want bool
- }{
- {module: "Docs", folder: "web/Office", want: false}, //Sheets is still on
- {module: "Sheets", folder: "web/Office", want: true}, //now all off
- {module: "Sheets", enabled: true, folder: "web/office", want: false},
- {module: "Setup Wizard", folder: "./web/Setup Wizard/", want: true},
- {module: "Photo", folder: "web/SystemAO", want: false}, //folder without disabled modules
- }
- for _, step := range steps {
- if err := mh.SetModuleEnabled(step.module, step.enabled); err != nil {
- t.Fatalf("SetModuleEnabled(%q, %v): %v", step.module, step.enabled, err)
- }
- if got := mh.IsSourceFolderDisabled(step.folder); got != step.want {
- t.Errorf("after SetModuleEnabled(%q, %v): IsSourceFolderDisabled(%q) = %v, want %v",
- step.module, step.enabled, step.folder, got, step.want)
- }
- }
- if mh.IsSourceFolderDisabled("") {
- t.Error("an empty folder is never disabled")
- }
- }
- func TestUninstallForgetsDisabledModule(t *testing.T) {
- store := newMemStore()
- mh := newDisableTestHandler(t, store)
- if err := mh.SetModuleEnabled("Photo", false); err != nil {
- t.Fatalf("disable Photo: %v", err)
- }
- mh.forgetDisabled("Photo")
- if mh.IsModuleDisabled("Photo") || len(mh.DisabledModule) != 0 || len(store.rows) != 0 {
- t.Errorf("forgetDisabled left state behind: disabled=%v list=%q rows=%d",
- mh.IsModuleDisabled("Photo"), moduleNames(mh.DisabledModule), len(store.rows))
- }
- if err := mh.UninstallModule("NoSuchModule"); err == nil {
- t.Error("UninstallModule of an unknown module should fail instead of panicking")
- }
- }
- func TestHandleSetModuleEnabled(t *testing.T) {
- tests := []struct {
- name string
- method string
- form url.Values
- wantBody string
- }{
- {name: "GET refused", method: http.MethodGet, wantBody: "must be a POST"},
- {name: "missing module", method: http.MethodPost, form: url.Values{"enabled": {"false"}}, wantBody: "Invalid module name"},
- {name: "missing state", method: http.MethodPost, form: url.Values{"module": {"Photo"}}, wantBody: "Invalid enabled state"},
- {name: "protected module", method: http.MethodPost, form: url.Values{"module": {"Desktop"}, "enabled": {"false"}}, wantBody: "cannot be disabled"},
- {name: "disable", method: http.MethodPost, form: url.Values{"module": {"Photo"}, "enabled": {"false"}}, wantBody: "OK"},
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- mh := newDisableTestHandler(t, newMemStore())
- req := httptest.NewRequest(tt.method, "/system/modules/setEnabled", strings.NewReader(tt.form.Encode()))
- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
- rec := httptest.NewRecorder()
- mh.HandleSetModuleEnabled(rec, req)
- if !strings.Contains(rec.Body.String(), tt.wantBody) {
- t.Errorf("body = %q, want it to contain %q", rec.Body.String(), tt.wantBody)
- }
- })
- }
- }
|