Binary tests (#146)

* test that Buffer key returns as ArrayBuffer with keyAsBuffer=false

* test that Buffer value returns as Uint8Array with asBuffer=false

* test combinations of Buffer/ArrayBuffer/Uint8Array values and asBuffer true/false

* remove obsolete comment

Author: vweevers

test/custom-test.js

@@ -47,7 +47,7 @@ module.exports = function (leveljs, test, testCommon) {
     })
   })
 
-  test('buffer value', function (t) {
+  test('put Buffer value, get Buffer value', function (t) {
     var level = leveljs(testCommon.location())
     level.open(function (err) {
       t.notOk(err, 'no error')
@@ -63,6 +63,88 @@ module.exports = function (leveljs, test, testCommon) {
     })
   })
 
+  test('put Buffer value, get Uint8Array value', function (t) {
+    var level = leveljs(testCommon.location())
+    level.open(function (err) {
+      t.notOk(err, 'no error')
+      level.put('key', Buffer.from('00ff', 'hex'), function (err) {
+        t.notOk(err, 'no error')
+        level.get('key', { asBuffer: false }, function (err, value) {
+          t.notOk(err, 'no error')
+          t.notOk(Buffer.isBuffer(value), 'is not a buffer')
+          t.ok(value instanceof Uint8Array, 'is a Uint8Array')
+          t.same(Buffer.from(value), Buffer.from('00ff', 'hex'))
+          level.close(t.end.bind(t))
+        })
+      })
+    })
+  })
+
+  test('put Uint8Array value, get Buffer value', function (t) {
+    var level = leveljs(testCommon.location())
+    level.open(function (err) {
+      t.notOk(err, 'no error')
+      level.put('key', new Uint8Array(Buffer.from('00ff', 'hex').buffer), function (err) {
+        t.notOk(err, 'no error')
+        level.get('key', function (err, value) {
+          t.notOk(err, 'no error')
+          t.ok(Buffer.isBuffer(value), 'is buffer')
+          t.same(value, Buffer.from('00ff', 'hex'))
+          level.close(t.end.bind(t))
+        })
+      })
+    })
+  })
+
+  test('put Uint8Array value, get Uint8Array value', function (t) {
+    var level = leveljs(testCommon.location())
+    level.open(function (err) {
+      t.notOk(err, 'no error')
+      level.put('key', new Uint8Array(Buffer.from('00ff', 'hex').buffer), function (err) {
+        t.notOk(err, 'no error')
+        level.get('key', { asBuffer: false }, function (err, value) {
+          t.notOk(err, 'no error')
+          t.notOk(Buffer.isBuffer(value), 'is not a buffer')
+          t.ok(value instanceof Uint8Array, 'is a Uint8Array')
+          t.same(Buffer.from(value), Buffer.from('00ff', 'hex'))
+          level.close(t.end.bind(t))
+        })
+      })
+    })
+  })
+
+  test('put ArrayBuffer value, get Buffer value', function (t) {
+    var level = leveljs(testCommon.location())
+    level.open(function (err) {
+      t.notOk(err, 'no error')
+      level.put('key', Buffer.from('00ff', 'hex').buffer, function (err) {
+        t.notOk(err, 'no error')
+        level.get('key', function (err, value) {
+          t.notOk(err, 'no error')
+          t.ok(Buffer.isBuffer(value), 'is buffer')
+          t.same(value, Buffer.from('00ff', 'hex'))
+          level.close(t.end.bind(t))
+        })
+      })
+    })
+  })
+
+  test('put ArrayBuffer value, get ArrayBuffer value', function (t) {
+    var level = leveljs(testCommon.location())
+    level.open(function (err) {
+      t.notOk(err, 'no error')
+      level.put('key', Buffer.from('00ff', 'hex').buffer, function (err) {
+        t.notOk(err, 'no error')
+        level.get('key', { asBuffer: false }, function (err, value) {
+          t.notOk(err, 'no error')
+          t.ok(value instanceof ArrayBuffer, 'is a ArrayBuffer')
+          t.same(Buffer.from(value), Buffer.from('00ff', 'hex'))
+          level.close(t.end.bind(t))
+        })
+      })
+    })
+  })
+
   // This should be covered by abstract-leveldown tests, but that's
   // prevented by process.browser checks (Level/abstract-leveldown#121).
   // This test is adapted from memdown.

test/key-type-test.js

@@ -16,6 +16,7 @@ var types = [
   { type: 'ArrayBuffer', ctor: true, allowFailure: true, key: ta(Buffer).buffer },
   { type: 'Int8Array', ctor: true, allowFailure: true, createKey: ta, view: true },
   { type: 'Uint8Array', ctor: true, allowFailure: true, createKey: ta, view: true },
+  { name: 'Buffer', type: 'Uint8Array', ctor: true, allowFailure: true, key: ta(Buffer), view: true },
   { type: 'Uint8ClampedArray', ctor: true, allowFailure: true, createKey: ta, view: true },
   { type: 'Int16Array', ctor: true, allowFailure: true, createKey: ta, view: true },
   { type: 'Uint16Array', ctor: true, allowFailure: true, createKey: ta, view: true },

test/structured-clone-test.js

@@ -42,6 +42,7 @@ var types = [
 
   // Don't allow failure as this is the primary type for binary (Buffer) data
   { type: 'Uint8Array', ctor: true, createValue: ta },
+  { name: 'Buffer', type: 'Uint8Array', ctor: true, value: ta(Buffer) },
 
   { type: 'Uint8ClampedArray', ctor: true, allowFailure: true, createValue: ta },
   { type: 'Int16Array', ctor: true, allowFailure: true, createValue: ta },

util/mixed-to-buffer.js

@@ -4,6 +4,6 @@ var toBuffer = require('typedarray-to-buffer')
 
 module.exports = function (value) {
   if (value instanceof Uint8Array) return toBuffer(value)
-  else if (value instanceof ArrayBuffer) return Buffer.from(value) // For keys.
+  else if (value instanceof ArrayBuffer) return Buffer.from(value)
   else return Buffer.from(String(value))
 }