@automerge/automerge-repo 1.0.13 → 1.0.14

package/test/StorageSubsystem.test.ts

@@ -8,6 +8,8 @@ import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/AutomergeUrl.js"
 import { StorageSubsystem } from "../src/storage/StorageSubsystem.js"
 import { DummyStorageAdapter } from "./helpers/DummyStorageAdapter.js"
+import { cbor } from "../src/index.js"
+import { pause } from "../src/helpers/pause.js"
 
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "automerge-repo-tests"))
 
@@ -19,55 +21,161 @@ describe("StorageSubsystem", () => {
 
   Object.entries(adaptersToTest).forEach(([adapterName, adapter]) => {
     describe(adapterName, () => {
-      it("can store and retrieve an Automerge document", async () => {
-        const storage = new StorageSubsystem(adapter)
+      describe("Automerge document storage", () => {
+        it("stores and retrieves an Automerge document", async () => {
+          const storage = new StorageSubsystem(adapter)
 
-        const doc = A.change(A.init<any>(), "test", d => {
-          d.foo = "bar"
+          const doc = A.change(A.init<any>(), "test", d => {
+            d.foo = "bar"
+          })
+
+          // save it to storage
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+          await storage.saveDoc(key, doc)
+
+          // reload it from storage
+          const reloadedDoc = await storage.loadDoc(key)
+
+          // check that it's the same doc
+          assert.deepStrictEqual(reloadedDoc, doc)
+        })
+
+        it("retrieves an Automerge document following lots of changes", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          type TestDoc = { foo: number }
+
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+
+          let doc = A.init<TestDoc>()
+
+          const N = 100
+          for (let i = 0; i < N; i++) {
+            doc = A.change(doc, "test", d => {
+              d.foo = i
+            })
+            // save it to storage
+            await storage.saveDoc(key, doc)
+          }
+
+          // reload it from storage, simulating a new process
+          const storage2 = new StorageSubsystem(adapter)
+          const reloadedDoc = await storage2.loadDoc<TestDoc>(key)
+
+          // check that the doc has the right value
+          assert.equal(reloadedDoc?.foo, N - 1)
         })
 
-        // save it to storage
-        const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
-        await storage.saveDoc(key, doc)
+        it("stores incremental changes following a load", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const doc = A.change(A.init<any>(), "test", d => {
+            d.foo = "bar"
+          })
+
+          // save it to storage
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+          storage.saveDoc(key, doc)
+
+          // reload it from storage, simulating a new process
+          const storage2 = new StorageSubsystem(adapter)
+          const reloadedDoc = await storage2.loadDoc(key)
+
+          assert(reloadedDoc, "doc should be loaded")
+
+          // make a change
+          const changedDoc = A.change<any>(reloadedDoc, "test 2", d => {
+            d.foo = "baz"
+          })
+
+          // save it to storage
+          storage2.saveDoc(key, changedDoc)
+        })
+
+        it("removes an Automerge document", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const doc = A.change(A.init<any>(), "test", d => {
+            d.foo = "bar"
+          })
+
+          // save it to storage
+          const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
+          await storage.saveDoc(key, doc)
 
-        // reload it from storage
-        const reloadedDoc = await storage.loadDoc(key)
+          // reload it from storage
+          const reloadedDoc = await storage.loadDoc(key)
 
-        // check that it's the same doc
-        assert.deepStrictEqual(reloadedDoc, doc)
+          // check that it's the same doc
+          assert.deepStrictEqual(reloadedDoc, doc)
+
+          // remove it
+          await storage.removeDoc(key)
+
+          // reload it from storage
+          const reloadedDoc2 = await storage.loadDoc(key)
+
+          // check that it's undefined
+          assert.equal(reloadedDoc2, undefined)
+        })
       })
-    })
-  })
 
-  it("correctly stores incremental changes following a load", async () => {
-    const adapter = new DummyStorageAdapter()
-    const storage = new StorageSubsystem(adapter)
+      describe("Arbitrary key/value storage", () => {
+        it("stores and retrieves a blob", async () => {
+          const storage = new StorageSubsystem(adapter)
 
-    const doc = A.change(A.init<any>(), "test", d => {
-      d.foo = "bar"
-    })
+          const value = cbor.encode({ foo: "bar" })
 
-    // save it to storage
-    const key = parseAutomergeUrl(generateAutomergeUrl()).documentId
-    storage.saveDoc(key, doc)
+          const namespace = "MyCoolAdapter"
+          const key = "ABC123"
+          await storage.save(namespace, key, value)
 
-    // create new storage subsystem to simulate a new process
-    const storage2 = new StorageSubsystem(adapter)
+          const reloadedValue = await storage.load(namespace, key)
+          assert.notEqual(reloadedValue, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue)["foo"], "bar")
+        })
 
-    // reload it from storage
-    const reloadedDoc = await storage2.loadDoc(key)
+        it("keeps namespaces separate", async () => {
+          const storage = new StorageSubsystem(adapter)
 
-    assert(reloadedDoc, "doc should be loaded")
+          const key = "ABC123"
 
-    // make a change
-    const changedDoc = A.change<any>(reloadedDoc, "test 2", d => {
-      d.foo = "baz"
-    })
+          const namespace1 = "MyCoolAdapter"
+          const value1 = cbor.encode({ foo: "bar" })
+          await storage.save(namespace1, key, value1)
+
+          const namespace2 = "SomeDumbAdapter"
+          const value2 = cbor.encode({ baz: "pizza" })
+          await storage.save(namespace2, key, value2)
 
-    // save it to storage
-    storage2.saveDoc(key, changedDoc)
+          const reloadedValue1 = await storage.load(namespace1, key)
+          assert.notEqual(reloadedValue1, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue1)["foo"], "bar")
 
-    // check that the storage adapter contains the correct keys
-    assert(adapter.keys().some(k => k.startsWith(`${key}.incremental.`)))
+          const reloadedValue2 = await storage.load(namespace2, key)
+          assert.notEqual(reloadedValue2, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue2)["baz"], "pizza")
+        })
+
+        it("removes a blob", async () => {
+          const storage = new StorageSubsystem(adapter)
+
+          const value = cbor.encode({ foo: "bar" })
+
+          const namespace = "MyCoolAdapter"
+          const key = "ABC123"
+          await storage.save(namespace, key, value)
+
+          const reloadedValue = await storage.load(namespace, key)
+          assert.notEqual(reloadedValue, undefined)
+          assert.deepEqual(cbor.decode(reloadedValue)["foo"], "bar")
+
+          await storage.remove(namespace, key)
+
+          const reloadedValue2 = await storage.load(namespace, key)
+          assert.equal(reloadedValue2, undefined)
+        })
+      })
+    })
   })
 })

package/test/helpers/DummyStorageAdapter.ts

@@ -1,4 +1,4 @@
-import { StorageAdapter, type StorageKey } from "../../src/index.js"
+import { Chunk, StorageAdapter, type StorageKey } from "../../src/index.js"
 
 export class DummyStorageAdapter implements StorageAdapter {
   #data: Record<string, Uint8Array> = {}
@@ -11,9 +11,7 @@ export class DummyStorageAdapter implements StorageAdapter {
     return key.split(".")
   }
 
-  async loadRange(
-    keyPrefix: StorageKey
-  ): Promise<{ data: Uint8Array; key: StorageKey }[]> {
+  async loadRange(keyPrefix: StorageKey): Promise<Chunk[]> {
     const range = Object.entries(this.#data)
       .filter(([key, _]) => key.startsWith(this.#keyToString(keyPrefix)))
       .map(([key, data]) => ({ key: this.#stringToKey(key), data }))