@automerge/automerge-repo 1.0.6 → 1.0.8

package/test/CollectionSynchronizer.test.ts

@@ -1,5 +1,5 @@
 import assert from "assert"
-import { beforeEach } from "mocha"
+import { beforeEach, describe, it } from "vitest"
 import { PeerId, Repo } from "../src/index.js"
 import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
 
@@ -18,56 +18,61 @@ describe("CollectionSynchronizer", () => {
     assert(synchronizer !== null)
   })
 
-  it("starts synchronizing a document to peers when added", done => {
-    const handle = repo.create()
-    synchronizer.addPeer("peer1" as PeerId)
-
-    synchronizer.once("message", event => {
-      assert(event.targetId === "peer1")
-      assert(event.documentId === handle.documentId)
-      done()
-    })
-
-    synchronizer.addDocument(handle.documentId)
-  })
-
-  it("starts synchronizing existing documents when a peer is added", done => {
-    const handle = repo.create()
-    synchronizer.addDocument(handle.documentId)
-    synchronizer.once("message", event => {
-      assert(event.targetId === "peer1")
-      assert(event.documentId === handle.documentId)
-      done()
-    })
-    synchronizer.addPeer("peer1" as PeerId)
-  })
-
-  it("should not synchronize to a peer which is excluded from the share policy", done => {
-    const handle = repo.create()
-
-    repo.sharePolicy = async (peerId: PeerId) => peerId !== "peer1"
-
-    synchronizer.addDocument(handle.documentId)
-    synchronizer.once("message", () => {
-      done(new Error("Should not have sent a message"))
-    })
-    synchronizer.addPeer("peer1" as PeerId)
-
-    setTimeout(done)
-  })
-
-  it("should not synchronize a document which is excluded from the share policy", done => {
-    const handle = repo.create()
-    repo.sharePolicy = async (_, documentId) => documentId !== handle.documentId
-
-    synchronizer.addPeer("peer2" as PeerId)
-
-    synchronizer.once("message", () => {
-      done(new Error("Should not have sent a message"))
-    })
-
-    synchronizer.addDocument(handle.documentId)
-
-    setTimeout(done)
-  })
+  it("starts synchronizing a document to peers when added", () =>
+    new Promise<void>(done => {
+      const handle = repo.create()
+      synchronizer.addPeer("peer1" as PeerId)
+
+      synchronizer.once("message", event => {
+        assert(event.targetId === "peer1")
+        assert(event.documentId === handle.documentId)
+        done()
+      })
+
+      synchronizer.addDocument(handle.documentId)
+    }))
+
+  it("starts synchronizing existing documents when a peer is added", () =>
+    new Promise<void>(done => {
+      const handle = repo.create()
+      synchronizer.addDocument(handle.documentId)
+      synchronizer.once("message", event => {
+        assert(event.targetId === "peer1")
+        assert(event.documentId === handle.documentId)
+        done()
+      })
+      synchronizer.addPeer("peer1" as PeerId)
+    }))
+
+  it("should not synchronize to a peer which is excluded from the share policy", () =>
+    new Promise<void>((done, reject) => {
+      const handle = repo.create()
+
+      repo.sharePolicy = async (peerId: PeerId) => peerId !== "peer1"
+
+      synchronizer.addDocument(handle.documentId)
+      synchronizer.once("message", () => {
+        reject(new Error("Should not have sent a message"))
+      })
+      synchronizer.addPeer("peer1" as PeerId)
+
+      setTimeout(done)
+    }))
+
+  it("should not synchronize a document which is excluded from the share policy", () =>
+    new Promise<void>((done, reject) => {
+      const handle = repo.create()
+      repo.sharePolicy = async (_, documentId) =>
+        documentId !== handle.documentId
+
+      synchronizer.addPeer("peer2" as PeerId)
+
+      synchronizer.once("message", () => {
+        reject(new Error("Should not have sent a message"))
+      })
+
+      synchronizer.addDocument(handle.documentId)
+
+      setTimeout(done)
+    }))
 })

package/test/DocHandle.test.ts

@@ -1,16 +1,15 @@
 import * as A from "@automerge/automerge/next"
 import assert from "assert"
-import { it } from "mocha"
-import { DocHandle, DocHandleChangePayload } from "../src/index.js"
-import { pause } from "../src/helpers/pause.js"
-import { TestDoc } from "./types.js"
+import { decode } from "cbor-x"
+import { describe, it } from "vitest"
 import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
-import { decode } from "cbor-x"
+import { pause } from "../src/helpers/pause.js"
+import { DocHandle, DocHandleChangePayload } from "../src/index.js"
+import { TestDoc } from "./types.js"
 
 describe("DocHandle", () => {
   const TEST_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
-  const BOGUS_ID = parseAutomergeUrl(generateAutomergeUrl()).documentId
 
   const docFromMockStorage = (doc: A.Doc<{ foo: string }>) => {
     return A.change<{ foo: string }>(doc, d => (d.foo = "bar"))
@@ -90,7 +89,7 @@ describe("DocHandle", () => {
 
     assert.equal(handle.docSync(), undefined)
     assert.equal(handle.isReady(), false)
-    assert.throws(() => handle.change(_ => { }))
+    assert.throws(() => handle.change(_ => {}))
   })
 
   it("should become ready if the document is updated by the network", async () => {
@@ -128,16 +127,17 @@ describe("DocHandle", () => {
     assert.deepStrictEqual(changePayload.handle, handle)
   })
 
-  it("should not emit a change message if no change happens via update", done => {
-    const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
-    handle.once("change", () => {
-      done(new Error("shouldn't have changed"))
-    })
-    handle.update(d => {
-      setTimeout(done, 0)
-      return d
-    })
-  })
+  it("should not emit a change message if no change happens via update", () =>
+    new Promise<void>((done, reject) => {
+      const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
+      handle.once("change", () => {
+        reject(new Error("shouldn't have changed"))
+      })
+      handle.update(d => {
+        setTimeout(done, 0)
+        return d
+      })
+    }))
 
   it("should update the internal doc prior to emitting the change message", async () => {
     const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
@@ -200,28 +200,27 @@ describe("DocHandle", () => {
     assert.equal(doc?.foo, "bar")
   })
 
-  it("should not emit a patch message if no change happens", done => {
-    const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
-    handle.on("change", () => {
-      done(new Error("shouldn't have changed"))
-    })
-    handle.change(_doc => {
-      // do nothing
-      setTimeout(done, 0)
-    })
-  })
+  it("should not emit a patch message if no change happens", () =>
+    new Promise<void>((done, reject) => {
+      const handle = new DocHandle<TestDoc>(TEST_ID, { isNew: true })
+      handle.on("change", () => {
+        reject(new Error("shouldn't have changed"))
+      })
+      handle.change(_doc => {
+        // do nothing
+        setTimeout(done, 0)
+      })
+    }))
 
-  it("should time out if the document is not loaded", async () => {
+  it("should be undefined if loading the document times out", async () => {
     // set docHandle time out after 5 ms
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
-    // we're not going to load
-    await pause(10)
+    const doc = await handle.doc()
 
-    assert.equal(handle.state, "failed")
+    assert.equal(doc, undefined)
 
-    // so it should time out
-    return assert.rejects(handle.doc, "DocHandle timed out")
+    assert.equal(handle.state, "failed")
   })
 
   it("should not time out if the document is loaded in time", async () => {
@@ -236,7 +235,7 @@ describe("DocHandle", () => {
     assert.equal(doc?.foo, "bar")
   })
 
-  it("should time out if the document is not updated from the network", async () => {
+  it("should be undefined if loading from the network times out", async () => {
     // set docHandle time out after 5 ms
     const handle = new DocHandle<TestDoc>(TEST_ID, { timeoutDelay: 5 })
 
@@ -246,8 +245,8 @@ describe("DocHandle", () => {
     // there's no update
     await pause(10)
 
-    // so it should time out
-    return assert.rejects(handle.doc, "DocHandle timed out")
+    const doc = await handle.doc()
+    assert.equal(doc, undefined)
   })
 
   it("should not time out if the document is updated in time", async () => {

package/test/DocSynchronizer.test.ts

@@ -1,18 +1,15 @@
 import assert from "assert"
-import { BinaryDocumentId, PeerId } from "../src/types.js"
+import { describe, it } from "vitest"
 import { DocHandle } from "../src/DocHandle.js"
-import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
+import { generateAutomergeUrl, parseAutomergeUrl } from "../src/DocUrl.js"
 import { eventPromise } from "../src/helpers/eventPromise.js"
-import { TestDoc } from "./types.js"
-import { parseAutomergeUrl, generateAutomergeUrl } from "../src/DocUrl.js"
-import { SyncMessage } from "../src/index.js"
 import {
   DocumentUnavailableMessage,
-  DocumentUnavailableMessageContents,
   MessageContents,
-  RequestMessageContents,
-  SyncMessageContents,
 } from "../src/network/messages.js"
+import { DocSynchronizer } from "../src/synchronizer/DocSynchronizer.js"
+import { PeerId } from "../src/types.js"
+import { TestDoc } from "./types.js"
 
 const alice = "alice" as PeerId
 const bob = "bob" as PeerId

package/test/Network.test.ts

@@ -1,4 +1,5 @@
 import assert from "assert"
+import { describe, it } from "vitest"
 import { NetworkSubsystem } from "../src/network/NetworkSubsystem.js"
 
 // Note: The sync tests in `Repo.test.ts` exercise the network subsystem, and the suite in