persistence_test.go 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309
  1. package sharedspace
  2. import (
  3. "bytes"
  4. "os"
  5. "path/filepath"
  6. "strings"
  7. "testing"
  8. "time"
  9. "imuslab.com/arozos/mod/database"
  10. )
  11. // persistenceEnv keeps the shared db file + roots so a "restart" can be
  12. // simulated by building a second manager over the same state.
  13. type persistenceEnv struct {
  14. dbfile string
  15. ephemeral string
  16. persistRoot string
  17. }
  18. func newPersistenceEnv(t *testing.T) *persistenceEnv {
  19. t.Helper()
  20. base := t.TempDir()
  21. return &persistenceEnv{
  22. dbfile: filepath.Join(base, "test.db"),
  23. ephemeral: filepath.Join(base, "ephemeral"),
  24. persistRoot: filepath.Join(base, "persist"),
  25. }
  26. }
  27. // open builds a manager over the environment, closing the db at test end.
  28. func (env *persistenceEnv) open(t *testing.T) (*Manager, *database.Database) {
  29. t.Helper()
  30. db, err := database.NewDatabase(env.dbfile, false)
  31. if err != nil {
  32. t.Fatalf("NewDatabase() error = %v", err)
  33. }
  34. m := NewManagerWithOptions(ManagerOptions{
  35. EphemeralRoot: env.ephemeral,
  36. PersistentRoot: env.persistRoot,
  37. Database: db,
  38. })
  39. return m, db
  40. }
  41. func TestPersistenceRoundTrip(t *testing.T) {
  42. env := newPersistenceEnv(t)
  43. m1, db1 := env.open(t)
  44. //Build a persistent space with the full feature surface
  45. space, err := m1.CreateSpaceWithOptions("alice", "Team chat", SpaceOptions{
  46. Access: AccessPrivate,
  47. Persistent: true,
  48. Metadata: map[string]string{"purpose": "chat"},
  49. })
  50. if err != nil {
  51. t.Fatalf("CreateSpaceWithOptions() error = %v", err)
  52. }
  53. space.AddMember("alice", "bob", RoleAdmin)
  54. space.SetMeta("alice", "topic", "launch")
  55. textItem, err := space.AddText("alice", "first message", "test")
  56. if err != nil {
  57. t.Fatalf("AddText() error = %v", err)
  58. }
  59. blobItem, err := space.SaveBlob(ItemTypeImage, "pic.png", "bob", "test", strings.NewReader("png-bytes"), 1024)
  60. if err != nil {
  61. t.Fatalf("SaveBlob() error = %v", err)
  62. }
  63. doc, err := space.CreateDoc("alice", "spec")
  64. if err != nil {
  65. t.Fatalf("CreateDoc() error = %v", err)
  66. }
  67. space.UpdateDoc("alice", doc.ID, 1, "v2")
  68. space.UpdateDoc("bob", doc.ID, 2, "v2 final")
  69. //An ephemeral space must NOT survive
  70. ephemeralSpace := m1.CreateSpace("alice", "throwaway")
  71. ephemeralSpace.AddText("alice", "gone after restart", "test")
  72. //Simulate a restart
  73. db1.Close()
  74. m2, db2 := env.open(t)
  75. defer db2.Close()
  76. if _, ok := m2.GetSpace(ephemeralSpace.ID); ok {
  77. t.Errorf("ephemeral space survived the restart")
  78. }
  79. restored, ok := m2.GetSpace(space.ID)
  80. if !ok {
  81. t.Fatalf("persistent space did not survive the restart")
  82. }
  83. //Space-level state
  84. if restored.Name != "Team chat" || restored.Owner != "alice" || !restored.Persistent {
  85. t.Errorf("restored space = %+v", restored)
  86. }
  87. if restored.AccessMode() != AccessPrivate {
  88. t.Errorf("restored access = %q, want private", restored.AccessMode())
  89. }
  90. if role, _ := restored.Role("bob"); role != RoleAdmin {
  91. t.Errorf("restored bob role = %q, want admin", role)
  92. }
  93. meta := restored.Metadata()
  94. if meta["purpose"] != "chat" || meta["topic"] != "launch" {
  95. t.Errorf("restored metadata = %v", meta)
  96. }
  97. //Items: order, content and blob bytes
  98. items := restored.Items()
  99. if len(items) != 2 {
  100. t.Fatalf("restored %d items, want 2", len(items))
  101. }
  102. if items[0].ID != textItem.ID || items[0].Text != "first message" {
  103. t.Errorf("first restored item = %+v", items[0])
  104. }
  105. if items[1].ID != blobItem.ID || items[1].Type != ItemTypeImage {
  106. t.Errorf("second restored item = %+v", items[1])
  107. }
  108. blobBytes, err := os.ReadFile(items[1].DiskPath)
  109. if err != nil || !bytes.Equal(blobBytes, []byte("png-bytes")) {
  110. t.Errorf("restored blob = %q, err = %v", blobBytes, err)
  111. }
  112. //New posts continue the sequence after the restored ones
  113. newItem, err := restored.AddText("bob", "after restart", "test")
  114. if err != nil {
  115. t.Fatalf("AddText() after restore error = %v", err)
  116. }
  117. if newItem.Seq <= items[1].Seq {
  118. t.Errorf("post-restart Seq %d not after restored max %d", newItem.Seq, items[1].Seq)
  119. }
  120. //Documents: content, revision and CAS across the restart
  121. restoredDoc, ok := restored.GetDoc(doc.ID)
  122. if !ok {
  123. t.Fatalf("document did not survive the restart")
  124. }
  125. if restoredDoc.Content != "v2 final" || restoredDoc.Revision != 3 || restoredDoc.UpdatedBy != "bob" {
  126. t.Errorf("restored doc = %+v", restoredDoc)
  127. }
  128. if _, err := restored.UpdateDoc("alice", doc.ID, 1, "stale"); err != ErrRevisionConflict {
  129. t.Errorf("stale update after restart error = %v, want ErrRevisionConflict", err)
  130. }
  131. if _, err := restored.UpdateDoc("alice", doc.ID, 3, "v3"); err != nil {
  132. t.Errorf("valid update after restart error = %v", err)
  133. }
  134. }
  135. func TestPersistentDeletionCleansDatabase(t *testing.T) {
  136. env := newPersistenceEnv(t)
  137. m1, db1 := env.open(t)
  138. space, _ := m1.CreateSpaceWithOptions("alice", "Doomed", SpaceOptions{Persistent: true})
  139. space.AddText("alice", "message", "test")
  140. blob, _ := space.SaveBlob(ItemTypeFile, "f.bin", "alice", "test", strings.NewReader("data"), 1024)
  141. doc, _ := space.CreateDoc("alice", "doc")
  142. _ = doc
  143. removedItemID := blob.ID
  144. space.RemoveItem(removedItemID, "alice")
  145. if db1.KeyExists(dbTableItems, space.ID+"/"+removedItemID) {
  146. t.Errorf("removed item record still in database")
  147. }
  148. m1.DeleteSpace(space.ID)
  149. if db1.KeyExists(dbTableSpaces, dbSpaceKeyPrefix+space.ID) {
  150. t.Errorf("space record still in database after DeleteSpace")
  151. }
  152. //After a restart nothing comes back
  153. db1.Close()
  154. m2, db2 := env.open(t)
  155. defer db2.Close()
  156. if m2.SpaceCount() != 0 {
  157. t.Errorf("deleted space resurrected: %d spaces", m2.SpaceCount())
  158. }
  159. }
  160. func TestReloadSelfHealing(t *testing.T) {
  161. env := newPersistenceEnv(t)
  162. m1, db1 := env.open(t)
  163. space, _ := m1.CreateSpaceWithOptions("alice", "Healing", SpaceOptions{Persistent: true})
  164. blob, _ := space.SaveBlob(ItemTypeFile, "f.bin", "alice", "test", strings.NewReader("data"), 1024)
  165. keeper, _ := space.AddText("alice", "keeper", "test")
  166. //Sabotage: blob file vanishes, an orphan item record points at a dead
  167. //space, and an orphan blob directory has no space
  168. os.Remove(blob.DiskPath)
  169. db1.Write(dbTableItems, "deadspace/deaditem", &itemRecord{ID: "deaditem", Type: ItemTypeText, Text: "orphan"})
  170. orphanDir := filepath.Join(env.persistRoot, "0000deadbeef0000")
  171. os.MkdirAll(orphanDir, 0755)
  172. db1.Close()
  173. m2, db2 := env.open(t)
  174. defer db2.Close()
  175. restored, ok := m2.GetSpace(space.ID)
  176. if !ok {
  177. t.Fatalf("space did not survive")
  178. }
  179. items := restored.Items()
  180. if len(items) != 1 || items[0].ID != keeper.ID {
  181. t.Errorf("restored items = %d, want only the keeper", len(items))
  182. }
  183. if db2.KeyExists(dbTableItems, space.ID+"/"+blob.ID) {
  184. t.Errorf("missing-blob item record not self-healed")
  185. }
  186. if db2.KeyExists(dbTableItems, "deadspace/deaditem") {
  187. t.Errorf("orphan item record not self-healed")
  188. }
  189. if _, err := os.Stat(orphanDir); !os.IsNotExist(err) {
  190. t.Errorf("orphan blob directory not removed")
  191. }
  192. }
  193. func TestPersistentTrimAtCap(t *testing.T) {
  194. env := newPersistenceEnv(t)
  195. m, db := env.open(t)
  196. defer db.Close()
  197. space, _ := m.CreateSpaceWithOptions("alice", "Trim", SpaceOptions{Persistent: true, MaxItems: 3})
  198. first, _ := space.AddText("alice", "one", "test")
  199. space.AddText("alice", "two", "test")
  200. space.AddText("alice", "three", "test")
  201. //Persistent spaces trim the oldest instead of failing
  202. fourth, err := space.AddText("alice", "four", "test")
  203. if err != nil {
  204. t.Fatalf("AddText at cap error = %v (persistent spaces must trim)", err)
  205. }
  206. if space.ItemCount() != 3 {
  207. t.Errorf("ItemCount() = %d, want 3", space.ItemCount())
  208. }
  209. if _, ok := space.GetItem(first.ID); ok {
  210. t.Errorf("oldest item still present after trim")
  211. }
  212. if db.KeyExists(dbTableItems, space.ID+"/"+first.ID) {
  213. t.Errorf("trimmed item record still in database")
  214. }
  215. if _, ok := space.GetItem(fourth.ID); !ok {
  216. t.Errorf("newest item missing after trim")
  217. }
  218. }
  219. func TestPersistenceToggle(t *testing.T) {
  220. env := newPersistenceEnv(t)
  221. m, db := env.open(t)
  222. defer db.Close()
  223. if !m.PersistenceAvailable() {
  224. t.Fatalf("PersistenceAvailable() = false on a persistence-enabled manager")
  225. }
  226. m.SetAllowPersistent(false)
  227. if m.PersistenceAvailable() {
  228. t.Errorf("PersistenceAvailable() = true after disable")
  229. }
  230. if _, err := m.CreateSpaceWithOptions("alice", "x", SpaceOptions{Persistent: true}); err != ErrPersistenceOff {
  231. t.Errorf("persistent create while disabled error = %v, want ErrPersistenceOff", err)
  232. }
  233. m.SetAllowPersistent(true)
  234. if _, err := m.CreateSpaceWithOptions("alice", "x", SpaceOptions{Persistent: true}); err != nil {
  235. t.Errorf("persistent create after re-enable error = %v", err)
  236. }
  237. }
  238. func TestSweepStaleSpaces(t *testing.T) {
  239. env := newPersistenceEnv(t)
  240. m, db := env.open(t)
  241. defer db.Close()
  242. stale, _ := m.CreateSpaceWithOptions("alice", "Stale", SpaceOptions{Persistent: true})
  243. fresh, _ := m.CreateSpaceWithOptions("alice", "Fresh", SpaceOptions{Persistent: true})
  244. fresh.AddText("alice", "recent activity", "test")
  245. occupied, _ := m.CreateSpaceWithOptions("alice", "Occupied", SpaceOptions{Persistent: true})
  246. occupied.Channel().Join("alice")
  247. ephemeral := m.CreateSpace("alice", "Ephemeral")
  248. //Backdate the stale and occupied spaces
  249. for _, space := range []*Space{stale, occupied} {
  250. space.mu.Lock()
  251. space.CreatedAt = time.Now().Add(-48 * time.Hour)
  252. space.mu.Unlock()
  253. }
  254. ephemeral.mu.Lock()
  255. ephemeral.CreatedAt = time.Now().Add(-48 * time.Hour)
  256. ephemeral.mu.Unlock()
  257. swept := m.SweepStaleSpaces(24 * time.Hour)
  258. if len(swept) != 1 || swept[0] != stale.ID {
  259. t.Errorf("SweepStaleSpaces() = %v, want [%s]", swept, stale.ID)
  260. }
  261. if _, ok := m.GetSpace(fresh.ID); !ok {
  262. t.Errorf("fresh space was swept")
  263. }
  264. if _, ok := m.GetSpace(occupied.ID); !ok {
  265. t.Errorf("occupied space was swept despite live subscriber")
  266. }
  267. if _, ok := m.GetSpace(ephemeral.ID); !ok {
  268. t.Errorf("ephemeral space was swept (not this sweeper's job)")
  269. }
  270. //maxAge <= 0 disables the sweep
  271. if swept := m.SweepStaleSpaces(0); swept != nil {
  272. t.Errorf("SweepStaleSpaces(0) = %v, want nil", swept)
  273. }
  274. }