disable_test.go 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254
  1. package modules
  2. import (
  3. "encoding/json"
  4. "errors"
  5. "net/http"
  6. "net/http/httptest"
  7. "net/url"
  8. "sort"
  9. "strings"
  10. "testing"
  11. )
  12. // memStore is a StateStore kept in memory
  13. type memStore struct {
  14. rows map[string][]byte
  15. failWrite bool
  16. }
  17. func newMemStore() *memStore {
  18. return &memStore{rows: map[string][]byte{}}
  19. }
  20. func (s *memStore) Write(table string, key string, value interface{}) error {
  21. if s.failWrite {
  22. return errors.New("disk full")
  23. }
  24. js, err := json.Marshal(value)
  25. if err != nil {
  26. return err
  27. }
  28. s.rows[table+"|"+key] = js
  29. return nil
  30. }
  31. func (s *memStore) Delete(table string, key string) error {
  32. delete(s.rows, table+"|"+key)
  33. return nil
  34. }
  35. func (s *memStore) ListTable(table string) ([][][]byte, error) {
  36. keys := []string{}
  37. for k := range s.rows {
  38. keys = append(keys, k)
  39. }
  40. sort.Strings(keys)
  41. result := [][][]byte{}
  42. for _, k := range keys {
  43. if strings.HasPrefix(k, table+"|") {
  44. result = append(result, [][]byte{[]byte(strings.TrimPrefix(k, table+"|")), s.rows[k]})
  45. }
  46. }
  47. return result, nil
  48. }
  49. func newDisableTestHandler(t *testing.T, store *memStore) *ModuleHandler {
  50. t.Helper()
  51. mh := &ModuleHandler{LoadedModule: []*ModuleInfo{}}
  52. if store != nil {
  53. if err := mh.LoadDisabledModules(store); err != nil {
  54. t.Fatalf("LoadDisabledModules: %v", err)
  55. }
  56. }
  57. for _, reg := range []struct{ folder, js string }{
  58. {"web/Photo", `{"Name":"Photo","Group":"Media","StartDir":"Photo/index.html"}`},
  59. {"web/Office", `{"Name":"Docs","Group":"Office"}`},
  60. {"web/Office", `{"Name":"Sheets","Group":"Office"}`},
  61. {"web/Setup Wizard", `{"Name":"Setup Wizard","Group":"Interface Module"}`},
  62. {"web/SystemAO", `{"Name":"System Setting","Group":"System Settings"}`},
  63. {"web/Tools", `{"Name":"Task Manager","Group":"System Tools"}`},
  64. } {
  65. if err := mh.RegisterModuleFromAGI(reg.folder, reg.js); err != nil {
  66. t.Fatalf("RegisterModuleFromAGI: %v", err)
  67. }
  68. }
  69. mh.RegisterModule(ModuleInfo{Name: "Desktop", Group: "Interface Module"})
  70. return mh
  71. }
  72. func moduleNames(list []*ModuleInfo) string {
  73. names := []string{}
  74. for _, m := range list {
  75. names = append(names, m.Name)
  76. }
  77. sort.Strings(names)
  78. return strings.Join(names, ",")
  79. }
  80. func TestSetModuleEnabled(t *testing.T) {
  81. tests := []struct {
  82. name string
  83. module string
  84. enabled bool
  85. usedBy []string
  86. wantErr string
  87. wantDisabled string
  88. }{
  89. {name: "disable a normal app", module: "Photo", wantDisabled: "Photo"},
  90. {name: "disable an interface module nobody boots into", module: "Setup Wizard", wantDisabled: "Setup Wizard"},
  91. {name: "system settings stay on", module: "System Setting", wantErr: "System modules"},
  92. {name: "system tools stay on", module: "Task Manager", wantErr: "System modules"},
  93. {name: "desktop stays on", module: "Desktop", wantErr: "System modules"},
  94. {name: "interface module still in use", module: "Setup Wizard", usedBy: []string{"administrator"}, wantErr: "administrator group opens this module"},
  95. {name: "unknown module", module: "Nope", wantErr: "not exists"},
  96. {name: "enabling an enabled module is a no-op", module: "Photo", enabled: true},
  97. }
  98. for _, tt := range tests {
  99. t.Run(tt.name, func(t *testing.T) {
  100. mh := newDisableTestHandler(t, newMemStore())
  101. mh.InterfaceModuleUsers = func(name string) []string {
  102. if name == tt.module {
  103. return tt.usedBy
  104. }
  105. return nil
  106. }
  107. err := mh.SetModuleEnabled(tt.module, tt.enabled)
  108. if tt.wantErr != "" {
  109. if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
  110. t.Fatalf("SetModuleEnabled(%q) error = %v, want %q", tt.module, err, tt.wantErr)
  111. }
  112. return
  113. }
  114. if err != nil {
  115. t.Fatalf("SetModuleEnabled(%q) unexpected error: %v", tt.module, err)
  116. }
  117. if got := moduleNames(mh.DisabledModule); got != tt.wantDisabled {
  118. t.Errorf("DisabledModule = %q, want %q", got, tt.wantDisabled)
  119. }
  120. if tt.wantDisabled != "" && mh.GetModuleInfoByID(tt.module) != nil {
  121. t.Errorf("GetModuleInfoByID(%q) still finds a disabled module", tt.module)
  122. }
  123. })
  124. }
  125. }
  126. func TestDisabledModuleSurvivesRestart(t *testing.T) {
  127. store := newMemStore()
  128. mh := newDisableTestHandler(t, store)
  129. if err := mh.SetModuleEnabled("Photo", false); err != nil {
  130. t.Fatalf("disable Photo: %v", err)
  131. }
  132. //A fresh handler reading the same store registers Photo as disabled at boot
  133. restarted := newDisableTestHandler(t, store)
  134. if restarted.GetModuleInfoByID("Photo") != nil {
  135. t.Fatal("Photo is loaded again after a restart")
  136. }
  137. if !restarted.IsModuleDisabled("photo") {
  138. t.Error("IsModuleDisabled should ignore case")
  139. }
  140. if got := moduleNames(restarted.DisabledModule); got != "Photo" {
  141. t.Errorf("DisabledModule after restart = %q, want Photo", got)
  142. }
  143. if err := restarted.SetModuleEnabled("Photo", true); err != nil {
  144. t.Fatalf("enable Photo: %v", err)
  145. }
  146. if restarted.GetModuleInfoByID("Photo") == nil {
  147. t.Fatal("Photo is not loaded after enabling it")
  148. }
  149. if len(store.rows) != 0 {
  150. t.Errorf("store still holds %d rows after enabling", len(store.rows))
  151. }
  152. //A protected module never registers as disabled, even with a stale row
  153. store.rows["module|disabled/System Setting"] = []byte("true")
  154. again := newDisableTestHandler(t, store)
  155. if again.GetModuleInfoByID("System Setting") == nil {
  156. t.Error("System Setting was kept off by a stale row")
  157. }
  158. }
  159. func TestSetModuleEnabledStoreFailure(t *testing.T) {
  160. store := newMemStore()
  161. mh := newDisableTestHandler(t, store)
  162. store.failWrite = true
  163. if err := mh.SetModuleEnabled("Photo", false); err == nil {
  164. t.Fatal("expected the store error to be returned")
  165. }
  166. if mh.GetModuleInfoByID("Photo") == nil || mh.IsModuleDisabled("Photo") {
  167. t.Error("a module that could not be saved as disabled must stay on")
  168. }
  169. }
  170. func TestIsSourceFolderDisabled(t *testing.T) {
  171. mh := newDisableTestHandler(t, newMemStore())
  172. steps := []struct {
  173. module string
  174. enabled bool
  175. folder string
  176. want bool
  177. }{
  178. {module: "Docs", folder: "web/Office", want: false}, //Sheets is still on
  179. {module: "Sheets", folder: "web/Office", want: true}, //now all off
  180. {module: "Sheets", enabled: true, folder: "web/office", want: false},
  181. {module: "Setup Wizard", folder: "./web/Setup Wizard/", want: true},
  182. {module: "Photo", folder: "web/SystemAO", want: false}, //folder without disabled modules
  183. }
  184. for _, step := range steps {
  185. if err := mh.SetModuleEnabled(step.module, step.enabled); err != nil {
  186. t.Fatalf("SetModuleEnabled(%q, %v): %v", step.module, step.enabled, err)
  187. }
  188. if got := mh.IsSourceFolderDisabled(step.folder); got != step.want {
  189. t.Errorf("after SetModuleEnabled(%q, %v): IsSourceFolderDisabled(%q) = %v, want %v",
  190. step.module, step.enabled, step.folder, got, step.want)
  191. }
  192. }
  193. if mh.IsSourceFolderDisabled("") {
  194. t.Error("an empty folder is never disabled")
  195. }
  196. }
  197. func TestUninstallForgetsDisabledModule(t *testing.T) {
  198. store := newMemStore()
  199. mh := newDisableTestHandler(t, store)
  200. if err := mh.SetModuleEnabled("Photo", false); err != nil {
  201. t.Fatalf("disable Photo: %v", err)
  202. }
  203. mh.forgetDisabled("Photo")
  204. if mh.IsModuleDisabled("Photo") || len(mh.DisabledModule) != 0 || len(store.rows) != 0 {
  205. t.Errorf("forgetDisabled left state behind: disabled=%v list=%q rows=%d",
  206. mh.IsModuleDisabled("Photo"), moduleNames(mh.DisabledModule), len(store.rows))
  207. }
  208. if err := mh.UninstallModule("NoSuchModule"); err == nil {
  209. t.Error("UninstallModule of an unknown module should fail instead of panicking")
  210. }
  211. }
  212. func TestHandleSetModuleEnabled(t *testing.T) {
  213. tests := []struct {
  214. name string
  215. method string
  216. form url.Values
  217. wantBody string
  218. }{
  219. {name: "GET refused", method: http.MethodGet, wantBody: "must be a POST"},
  220. {name: "missing module", method: http.MethodPost, form: url.Values{"enabled": {"false"}}, wantBody: "Invalid module name"},
  221. {name: "missing state", method: http.MethodPost, form: url.Values{"module": {"Photo"}}, wantBody: "Invalid enabled state"},
  222. {name: "protected module", method: http.MethodPost, form: url.Values{"module": {"Desktop"}, "enabled": {"false"}}, wantBody: "cannot be disabled"},
  223. {name: "disable", method: http.MethodPost, form: url.Values{"module": {"Photo"}, "enabled": {"false"}}, wantBody: "OK"},
  224. }
  225. for _, tt := range tests {
  226. t.Run(tt.name, func(t *testing.T) {
  227. mh := newDisableTestHandler(t, newMemStore())
  228. req := httptest.NewRequest(tt.method, "/system/modules/setEnabled", strings.NewReader(tt.form.Encode()))
  229. req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
  230. rec := httptest.NewRecorder()
  231. mh.HandleSetModuleEnabled(rec, req)
  232. if !strings.Contains(rec.Body.String(), tt.wantBody) {
  233. t.Errorf("body = %q, want it to contain %q", rec.Body.String(), tt.wantBody)
  234. }
  235. })
  236. }
  237. }