Update rave-level to be compatible with abstract-level 2.0 API

package.json

@@ -11,7 +11,7 @@
     "url": "http://substack.net"
   },
   "scripts": {
-    "test": "standard && ts-standard *.ts && hallmark && nyc tape test/*.js",
+    "test": "standard && ts-standard *.ts && hallmark && (nyc -s tape test/*.js | faucet) && nyc report",
     "coverage": "nyc report -r lcovonly",
     "hallmark": "hallmark --fix",
     "dependency-check": "dependency-check --no-dev . test/*.js",
@@ -24,15 +24,16 @@
     "UPGRADING.md"
   ],
   "dependencies": {
-    "classic-level": "^1.2.0",
-    "many-level": "^1.0.1",
+    "classic-level": "^2.0.0",
+    "many-level": "git+ssh://git@github.com/ForgeVTT/many-level.git#e3e77e4ab35f1a39e4c134228b061b70043da442",
     "module-error": "^1.0.2",
-    "readable-stream": "^3.6.0"
+    "readable-stream": "^4.0.0"
   },
   "devDependencies": {
     "@voxpelli/tsconfig": "^4.0.0",
     "bytewise": "^1.1.0",
     "dependency-check": "^4.1.0",
+    "faucet": "^0.0.4",
     "hallmark": "^4.1.0",
     "nyc": "^15.1.0",
     "standard": "^16.0.3",
@@ -56,6 +57,6 @@
     "socket"
   ],
   "engines": {
-    "node": ">=12"
+    "node": ">=16"
   }
 }

test/basic.js

@@ -6,33 +6,66 @@ const path = require('path')
 const events = require('events')
 const { RaveLevel } = require('..')
 
-test('two databases', function (t) {
+test('single database', async function (t) {
+  t.plan(1)
+
+  const location = tempy.directory()
+  const db = new RaveLevel(location, { valueEncoding: 'json' })
+  const value = Math.floor(Math.random() * 100000)
+
+  await db.put('a', value)
+  const x = await db.get('a')
+  t.is(x, value)
+
+  await db.close()
+})
+
+test('two databases', async function (t) {
+  t.plan(3)
+
+  const location = tempy.directory()
+  const db1 = new RaveLevel(location, { valueEncoding: 'json' })
+  const db2 = new RaveLevel(location, { valueEncoding: 'json' })
+  const value = Math.floor(Math.random() * 100000)
+
+  await db1.put('a', value)
+  const x = await db2.get('a')
+  t.is(x, value)
+
+  await db1.close()
+  t.is(db1.status, 'closed')
+
+  await db2.close()
+  t.is(db2.status, 'closed')
+})
+
+test('three databases', async function (t) {
   t.plan(5)
 
   const location = tempy.directory()
   const db1 = new RaveLevel(location, { valueEncoding: 'json' })
   const db2 = new RaveLevel(location, { valueEncoding: 'json' })
+  const db3 = new RaveLevel(location, { valueEncoding: 'json' })
   const value = Math.floor(Math.random() * 100000)
 
-  db1.put('a', value, function (err) {
-    t.ifError(err)
+  await db1.put('a', value)
+  const x = await db2.get('a')
+  const y = await db3.get('a')
+  t.is(x, value)
+  t.is(y, value)
 
-    db2.get('a', function (err, x) {
-      t.ifError(err)
-      t.is(x, value)
+  await db1.close()
+  t.is(db1.status, 'closed')
 
-      db1.close(function (err) {
-        t.ifError(err)
+  await db2.close()
+  t.is(db2.status, 'closed')
 
-        db2.close(function (err) {
-          t.ifError(err)
-        })
-      })
-    })
-  })
+  await db3.close()
+  t.is(db3.status, 'closed')
 })
 
 test('two locations do not conflict', async function (t) {
+  t.plan(2)
   const db1 = new RaveLevel(tempy.directory())
   const db2 = new RaveLevel(tempy.directory())
 

test/bytewise.js

@@ -5,35 +5,23 @@ const bytewise = require('bytewise')
 const tempy = require('./util/tempy')
 const { RaveLevel } = require('..')
 
-test('bytewise key encoding', function (t) {
-  t.plan(7)
+test('bytewise key encoding', async function (t) {
+  t.plan(3)
 
   const location = tempy.directory()
   const db1 = new RaveLevel(location, { keyEncoding: bytewise, valueEncoding: 'json' })
   const db2 = new RaveLevel(location, { keyEncoding: bytewise, valueEncoding: 'json' })
   const value = Math.floor(Math.random() * 100000)
 
-  db1.put(['a'], value, function (err) {
-    t.ifError(err)
+  await db1.put(['a'], value)
+  const x = await db2.get(['a'])
+  t.is(x, value)
 
-    db2.get(['a'], function (err, x) {
-      t.ifError(err)
-      t.is(x, value)
-    })
+  const db1Entries = await db1.iterator().all()
+  t.same(db1Entries, [[['a'], value]], 'a got correct entries')
+  const db2Entries = await db2.iterator().all()
+  t.same(db2Entries, [[['a'], value]], 'b got correct entries')
 
-    db1.iterator().all(function (err, entries) {
-      t.ifError(err)
-      t.same(entries, [[['a'], value]], 'a got correct entries')
-    })
-    db2.iterator().all(function (err, entries) {
-      t.ifError(err)
-      t.same(entries, [[['a'], value]], 'b got correct entries')
-    })
-  })
-
-  t.on('end', function () {
-    // TODO: await
-    db1.close()
-    db2.close()
-  })
+  await db1.close()
+  await db2.close()
 })

test/election.js

@@ -19,54 +19,56 @@ test('basic failover', async function (t) {
   t.same(await db2.values().all(), values)
 })
 
-test('failover election party', function (t) {
+test('failover election party', async function (t) {
   const location = tempy.directory()
   const keys = ['a', 'b', 'c', 'e', 'f', 'g']
   const len = keys.length
+  // Assertion count: 6+5+4+3+2+1 = 21 total (one per database per iteration)
   t.plan(len * (len + 1) / 2)
-  let pending = keys.length
+
   const databases = {}
 
-  keys.forEach(function (key) {
-    const h = open(key)
-    h.on('open', function () {
-      if (--pending === 0) spinDown()
+  // Open all databases and wait for them to be ready
+  await Promise.all(
+    keys.map(key => {
+      const db = new RaveLevel(location, { valueEncoding: 'json' })
+      databases[key] = db
+
+      // Wrap the 'open' event in a promise so we can await it
+      return new Promise((resolve, reject) => {
+        db.on('open', resolve)
+        db.on('error', reject)
+      })
     })
-  })
+  )
 
-  function open (key) {
-    const h = databases[key] = new RaveLevel(location, { valueEncoding: 'json' })
-    return h
-  }
+  // Test sequential failover: close databases one at a time while
+  // validating that remaining databases still replicate correctly
+  const alive = keys.slice() // Copy so we can mutate without affecting original
 
-  function spinDown () {
-    const alive = keys.slice();
-    (function next () {
-      if (alive.length === 0) return
+  while (alive.length > 0) {
+    // Validate circular replication across all remaining databases
+    // Each database writes a value that the next database should be able to read
+    for (let i = 0; i < alive.length; i++) {
+      const currentKey = alive[i]
+      const nextKey = alive[(i + 1) % alive.length] // Wrap around to first database
+      const value = Math.random()
 
-      check(alive, function () {
-        const key = alive.shift()
-        databases[key].close()
-        next()
-      })
-    })()
-  }
+      // Write to current database
+      await databases[currentKey].put(currentKey, value)
+
+      // Give the updated value a chance to propagate
+      await new Promise(resolve => setTimeout(resolve, 1))
 
-  function check (keys, cb) {
-    let pending = keys.length
-    if (pending === 0) return cb()
-    for (let i = 0; i < keys.length; i++) {
-      (function (a, b) {
-        const value = Math.random()
-        databases[a].put(a, value, function (err) {
-          if (err) t.fail(err)
-          databases[b].get(a, function (err, x) {
-            if (err) t.fail(err)
-            t.equal(x, value)
-            if (--pending === 0) cb()
-          })
-        })
-      })(keys[i], keys[(i + 1) % keys.length])
+      // Read from next database (should be replicated)
+      const retrieved = await databases[nextKey].get(currentKey)
+
+      // Verify the replicated value matches what we wrote
+      t.equal(retrieved, value)
     }
+
+    // Remove and close the first database in the remaining set
+    const key = alive.shift()
+    await databases[key].close()
   }
 })