Test encodings and snapshots

Author: vweevers

test/encoding-buffer-test.js

@@ -218,12 +218,10 @@ exports.all = function (test, testCommon) {
       const db = testCommon.factory({ keyEncoding })
       await db.open()
 
+      // These are equal when compared as strings but not when compared as buffers
       const one = Buffer.from('80', 'hex')
       const two = Buffer.from('c0', 'hex')
 
-      t.ok(two.toString() === one.toString(), 'would be equal when not byte-aware')
-      t.ok(two.compare(one) > 0, 'but greater when byte-aware')
-
       await db.put(one, 'one')
       t.is(await db.get(one), 'one', 'value one ok')
 
@@ -232,6 +230,65 @@ exports.all = function (test, testCommon) {
 
       return db.close()
     })
+
+    if (testCommon.supports.getSync) {
+      test(`storage is byte-aware (${keyEncoding} encoding) (sync)`, async function (t) {
+        const db = testCommon.factory({ keyEncoding })
+        await db.open()
+
+        // These are equal when compared as strings but not when compared as buffers
+        const one = Buffer.from('80', 'hex')
+        const two = Buffer.from('c0', 'hex')
+
+        await db.put(one, 'one')
+        t.is(db.getSync(one), 'one', 'value one ok')
+
+        await db.put(two, 'two')
+        t.is(db.getSync(one), 'one', 'value one did not change')
+
+        return db.close()
+      })
+    }
+
+    test(`respects buffer offset and length (${keyEncoding} encoding)`, async function (t) {
+      const db = testCommon.factory({ keyEncoding })
+      await db.open()
+
+      const a = Buffer.from('000102', 'hex')
+      const b = a.subarray(1) // 0102
+      const c = a.subarray(0, 1) // 00
+
+      await db.put(a, 'a')
+      await db.put(b, 'b')
+      await db.put(c, 'c')
+
+      t.is(await db.get(a), 'a', 'value a ok')
+      t.is(await db.get(b), 'b', 'value b ok')
+      t.is(await db.get(c), 'c', 'value c ok')
+
+      return db.close()
+    })
+
+    if (testCommon.supports.getSync) {
+      test(`respects buffer offset (${keyEncoding} encoding) (sync)`, async function (t) {
+        const db = testCommon.factory({ keyEncoding })
+        await db.open()
+
+        const a = Buffer.from('000102', 'hex')
+        const b = a.subarray(1) // 0102
+        const c = a.subarray(0, 1) // 00
+
+        await db.put(a, 'a')
+        await db.put(b, 'b')
+        await db.put(c, 'c')
+
+        t.is(db.getSync(a), 'a', 'value a ok')
+        t.is(db.getSync(b), 'b', 'value b ok')
+        t.is(db.getSync(c), 'c', 'value c ok')
+
+        return db.close()
+      })
+    }
   }
 }
 

test/encoding-custom-test.js

@@ -81,6 +81,12 @@ exports.all = function (test, testCommon) {
       t.same(await db.get(entry.key), entry.value)
     }
 
+    if (testCommon.supports.getSync) {
+      for (const entry of entries) {
+        t.same(db.getSync(entry.key), entry.value)
+      }
+    }
+
     return db.close()
   }
 }

test/encoding-decode-error-test.js

@@ -12,8 +12,8 @@ exports.all = function (test, testCommon) {
   })
 
   // NOTE: adapted from encoding-down
-  test('decode error is wrapped by get() and getMany()', async function (t) {
-    t.plan(4)
+  test('decode error is wrapped by get() and variants', async function (t) {
+    t.plan(testCommon.supports.getSync ? 6 : 4)
 
     const key = testKey()
     const valueEncoding = {
@@ -37,11 +37,20 @@ exports.all = function (test, testCommon) {
       t.is(err.code, 'LEVEL_DECODE_ERROR')
       t.is(err.cause.message, 'decode error xyz')
     }
+
+    if (testCommon.supports.getSync) {
+      try {
+        db.getSync(key, { valueEncoding })
+      } catch (err) {
+        t.is(err.code, 'LEVEL_DECODE_ERROR')
+        t.is(err.cause.message, 'decode error xyz')
+      }
+    }
   })
 
   // NOTE: adapted from encoding-down
-  test('get() and getMany() yield decode error if stored value is invalid', async function (t) {
-    t.plan(4)
+  test('get() and variants yield decode error if stored value is invalid', async function (t) {
+    t.plan(testCommon.supports.getSync ? 6 : 4)
 
     const key = testKey()
     await db.put(key, 'this {} is [] not : json', { valueEncoding: 'utf8' })
@@ -59,6 +68,15 @@ exports.all = function (test, testCommon) {
       t.is(err.code, 'LEVEL_DECODE_ERROR')
       t.is(err.cause.name, 'SyntaxError') // From JSON.parse()
     }
+
+    if (testCommon.supports.getSync) {
+      try {
+        db.getSync(key, { valueEncoding: 'json' })
+      } catch (err) {
+        t.is(err.code, 'LEVEL_DECODE_ERROR')
+        t.is(err.cause.name, 'SyntaxError') // From JSON.parse()
+      }
+    }
   })
 
   test('decode error teardown', async function (t) {

test/encoding-json-test.js

@@ -55,6 +55,12 @@ exports.all = function (test, testCommon) {
     await db.batch(operations)
     await Promise.all([...entries.map(testGet), testIterator()])
 
+    if (testCommon.supports.getSync) {
+      for (const entry of entries) {
+        t.same(db.getSync(entry.key), entry.value)
+      }
+    }
+
     return db.close()
 
     async function testGet (entry) {

test/encoding-test.js

@@ -59,6 +59,7 @@ exports.all = function (test, testCommon) {
       if (!deferred) await db.open()
       await db.put(1, 2)
       t.is(await db.get(1), '2')
+      testCommon.supports.getSync && t.is(db.getSync(1), '2')
       return db.close()
     })
   }
@@ -68,15 +69,25 @@ exports.all = function (test, testCommon) {
     const key = testKey()
     const data = { thisis: 'json' }
     await db.put(key, JSON.stringify(data), { valueEncoding: 'utf8' })
+
     t.same(await db.get(key, { valueEncoding: 'json' }), data, 'got parsed object')
+
+    if (testCommon.supports.getSync) {
+      t.same(db.getSync(key, { valueEncoding: 'json' }), data, 'got parsed object (sync)')
+    }
   })
 
   // NOTE: adapted from encoding-down
   test('can decode from json to string', async function (t) {
     const data = { thisis: 'json' }
     const key = testKey()
     await db.put(key, data, { valueEncoding: 'json' })
+
     t.same(await db.get(key, { valueEncoding: 'utf8' }), JSON.stringify(data), 'got unparsed JSON string')
+
+    if (testCommon.supports.getSync) {
+      t.same(db.getSync(key, { valueEncoding: 'utf8' }), JSON.stringify(data), 'got unparsed JSON string (sync)')
+    }
   })
 
   // NOTE: adapted from encoding-down

test/get-sync-test.js

@@ -53,7 +53,6 @@ exports.tearDown = function (test, testCommon) {
   })
 }
 
-// TODO: test encodings, snapshots
 exports.all = function (test, testCommon) {
   exports.setUp(test, testCommon)
   exports.args(test, testCommon)

test/iterator-explicit-snapshot-test.js

@@ -18,8 +18,6 @@ exports.get = function (test, testCommon) {
   const { testFresh, testClose } = testFactory(test, testCommon)
 
   testFresh('get() changed entry from snapshot', async function (t, db) {
-    t.plan(3)
-
     await db.put('abc', 'before')
     const snapshot = db.snapshot()
     await db.put('abc', 'after')
@@ -28,12 +26,16 @@ exports.get = function (test, testCommon) {
     t.is(await db.get('abc', { snapshot }), 'before')
     t.is(await db.get('other', { snapshot }), undefined)
 
+    if (testCommon.supports.getSync) {
+      t.is(db.getSync('abc'), 'after')
+      t.is(db.getSync('abc', { snapshot }), 'before')
+      t.is(db.getSync('other', { snapshot }), undefined)
+    }
+
     return snapshot.close()
   })
 
   testFresh('get() deleted entry from snapshot', async function (t, db) {
-    t.plan(3)
-
     await db.put('abc', 'before')
     const snapshot = db.snapshot()
     await db.del('abc')
@@ -42,27 +44,34 @@ exports.get = function (test, testCommon) {
     t.is(await db.get('abc', { snapshot }), 'before')
     t.is(await db.get('other', { snapshot }), undefined)
 
+    if (testCommon.supports.getSync) {
+      t.is(db.getSync('abc'), undefined)
+      t.is(db.getSync('abc', { snapshot }), 'before')
+      t.is(db.getSync('other', { snapshot }), undefined)
+    }
+
     return snapshot.close()
   })
 
   testFresh('get() non-existent entry from snapshot', async function (t, db) {
-    t.plan(2)
-
     const snapshot = db.snapshot()
     await db.put('abc', 'after')
 
     t.is(await db.get('abc'), 'after')
     t.is(await db.get('abc', { snapshot }), undefined)
 
+    if (testCommon.supports.getSync) {
+      t.is(db.getSync('abc'), 'after')
+      t.is(db.getSync('abc', { snapshot }), undefined)
+    }
+
     return snapshot.close()
   })
 
   testFresh('get() entries from multiple snapshots', async function (t, db) {
     const snapshots = []
     const iterations = 100
 
-    t.plan(iterations)
-
     for (let i = 0; i < iterations; i++) {
       await db.put('number', i.toString())
       snapshots.push(db.snapshot())
@@ -73,6 +82,10 @@ exports.get = function (test, testCommon) {
       const value = i.toString()
 
       t.is(await db.get('number', { snapshot }), value)
+
+      if (testCommon.supports.getSync) {
+        t.is(db.getSync('number', { snapshot }), value)
+      }
     }
 
     return Promise.all(snapshots.map(x => x.close()))
@@ -90,12 +103,22 @@ exports.get = function (test, testCommon) {
     // Closing one snapshot should not affect the other
     t.is(await db.get('abc', { snapshot: snapshot2 }), 'before')
 
+    if (testCommon.supports.getSync) {
+      t.is(db.getSync('abc', { snapshot: snapshot2 }), 'before')
+    }
+
     return snapshot2.close()
   })
 
   testClose('get()', async function (db, snapshot) {
     return db.get('xyz', { snapshot })
   })
+
+  if (testCommon.supports.getSync) {
+    testClose('getSync()', async function (db, snapshot) {
+      return db.getSync('xyz', { snapshot })
+    })
+  }
 }
 
 exports.getMany = function (test, testCommon) {

test/put-get-del-test.js

@@ -9,9 +9,20 @@ function makeTest (test, type, key, value, expectedValue) {
 
   test('put(), get(), del() with ' + type, async function (t) {
     await db.put(key, value)
+
     t.is((await db.get(key)).toString(), stringValue)
+
+    if (db.supports.getSync) {
+      t.is(db.getSync(key).toString(), stringValue)
+    }
+
     await db.del(key)
+
     t.is(await db.get(key), undefined, 'not found')
+
+    if (db.supports.getSync) {
+      t.is(db.getSync(key), undefined, 'not found')
+    }
   })
 }