Test all types of the structured clone algorithm (#101)

* stringify test doesn't require binary key support

* catch DataCloneError if env does not support serializing key or value

* test all types of the structured clone algorithm

Author: vweevers

index.js

@@ -6,6 +6,7 @@ var AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
 var util = require('util')
 var Iterator = require('./iterator')
 var mixedToBuffer = require('./util/mixed-to-buffer')
+var isDataCloneError = require('./util/is-data-clone-error')
 var setImmediate = require('./util/immediate')
 var support = require('./util/support')
 
@@ -89,7 +90,23 @@ Level.prototype._del = function(key, options, callback) {
 }
 
 Level.prototype._put = function (key, value, options, callback) {
-  this.await(this.store('readwrite').put(value, key), callback)
+  var store = this.store('readwrite')
+
+  try {
+    // Will throw a DataCloneError if the environment
+    // does not support serializing the key or value.
+    var req = store.put(value, key)
+  } catch (err) {
+    if (!isDataCloneError(err)) {
+      throw err
+    }
+
+    return setImmediate(function () {
+      callback(err)
+    })
+  }
+
+  this.await(req, callback)
 }
 
 // Valid key types in IndexedDB Second Edition:

test/custom-test.js

@@ -62,7 +62,7 @@ module.exports = function (leveljs, test, testCommon) {
   })
 
   // Adapted from a memdown test.
-  leveljs.binaryKeys && test('iterator stringifies buffer input', function (t) {
+  test('iterator stringifies buffer input', function (t) {
     t.plan(6)
 
     var db = leveljs(testCommon.location())
@@ -86,38 +86,6 @@ module.exports = function (leveljs, test, testCommon) {
     })
   })
 
-  // TODO: merge this and the test below. Test all types.
-  test('store native JS types', function(t) {
-    var level = leveljs(testCommon.location())
-    level.open(function(err) {
-      t.notOk(err, 'no error')
-      level.put('key', true, function (err) {
-        t.notOk(err, 'no error')
-        level.get('key', { asBuffer: false }, function(err, value) {
-          t.notOk(err, 'no error')
-          t.ok(typeof value === 'boolean', 'is boolean type')
-          t.ok(value, 'is truthy')
-          level.close(t.end.bind(t))
-        })
-      })
-    })
-  })
-
-  test('store NaN value', function(t) {
-    var level = leveljs(testCommon.location())
-    level.open(function(err) {
-      t.notOk(err, 'no error')
-      level.put('key', NaN, function (err) {
-        t.notOk(err, 'no error')
-        level.get('key', { asBuffer: false }, function(err, value) {
-          t.notOk(err, 'no error')
-          t.ok(typeof value === 'number' && isNaN(value), 'is NaN')
-          level.close(t.end.bind(t))
-        })
-      })
-    })
-  })
-
   // NOTE: in chrome (at least) indexeddb gets buggy if you try and destroy a db,
   // then create it again, then try and destroy it again. these avoid doing that
 

test/index.js

@@ -30,4 +30,5 @@ require('abstract-leveldown/abstract/iterator-range-test').all(leveljs, test, te
 
 // Additional tests for this implementation
 require('./custom-test')(leveljs, test, testCommon)
+require('./structured-clone-test')(leveljs, test, testCommon)
 require('./levelup-test')(leveljs, test, testCommon)

test/structured-clone-test.js

@@ -0,0 +1,202 @@
+'use strict'
+
+var levelup = require('levelup')
+var isDataCloneError = require('../util/is-data-clone-error')
+var bytes = [0, 127]
+
+// Replacement for TypedArray.from(bytes)
+function ta (TypedArray) {
+  var arr = new TypedArray(bytes.length)
+  for (var i = 0; i < bytes.length; i++) arr[i] = bytes[i]
+  return arr
+}
+
+// level-js supports all types of the structured clone algorithm
+// except for null and undefined (unless nested in another type).
+var types = [
+  { type: 'boolean', value: true },
+  { type: 'number', value: -20 },
+  {
+    type: 'NaN',
+    value: NaN,
+    test: function (value) {
+      // Replacement for Number.isNaN (for IE <= 11)
+      return typeof value === 'number' && isNaN(value)
+    }
+  },
+  { type: '+Infinity', value: Infinity },
+  { type: '-Infinity', value: -Infinity },
+  { type: 'string', value: 'test' },
+  { type: 'Boolean object', value: new Boolean(false) },
+  { type: 'String object', value: new String('test') },
+  { type: 'Date', ctor: true, value: new Date() },
+  { type: 'RegExp', ctor: true, value: /r/g },
+  { type: 'Array', ctor: true, value: [0, null, undefined] },
+  { type: 'Object', ctor: true, value: { a: null, b: [undefined] } },
+  {
+    type: 'Object',
+    name: 'Object (null prototype)',
+    ctor: true,
+    createValue: function () {
+      return Object.create(null)
+    }
+  },
+
+  { type: 'ArrayBuffer', ctor: true, allowFailure: true, value: ta(Buffer).buffer },
+  { type: 'Int8Array', ctor: true, allowFailure: true, createValue: ta },
+
+  // Don't allow failure as this is the primary type for binary (Buffer) data
+  { type: 'Uint8Array', ctor: true, createValue: ta },
+
+  { type: 'Uint8ClampedArray', ctor: true, allowFailure: true, createValue: ta },
+  { type: 'Int16Array', ctor: true, allowFailure: true, createValue: ta },
+  { type: 'Uint16Array', ctor: true, allowFailure: true, createValue: ta },
+  { type: 'Int32Array', ctor: true, allowFailure: true, createValue: ta },
+  { type: 'Uint32Array', ctor: true, allowFailure: true, createValue: ta },
+  { type: 'Float32Array', ctor: true, allowFailure: true, createValue: ta },
+  { type: 'Float64Array', ctor: true, allowFailure: true, createValue: ta },
+  {
+    type: 'Map',
+    ctor: true,
+    allowFailure: true,
+    createValue: function (ctor) {
+      // Replacement for Map constructor arguments (for IE 11)
+      var value = new ctor()
+      value.set('test', 123)
+      return value
+    },
+    test: function (value) {
+      return value.get('test') === 123
+    }
+  },
+  {
+    type: 'Set',
+    ctor: true,
+    allowFailure: true,
+    createValue: function (ctor) {
+      // Replacement for Set constructor arguments (for IE 11)
+      var value = new ctor()
+      value.add(123)
+      return value
+    },
+    test: function (value) {
+      return value.has(123)
+    }
+  },
+  {
+    type: 'Blob',
+    ctor: true,
+    allowFailure: true,
+    createValue: function (ctor) {
+      return new ctor(['test'])
+    },
+    test: function (value) {
+      // TODO. This test would be asynchronous.
+      return true
+    }
+  },
+  {
+    type: 'File',
+    ctor: true,
+    allowFailure: true,
+    createValue: function (ctor) {
+      return new ctor(['test'], 'filename')
+    },
+    test: function (value) {
+      // TODO. This test would be asynchronous.
+      return true
+    }
+  },
+  {
+    type: 'FileList',
+    ctor: true,
+    allowFailure: true,
+    createValue: function () {
+      var input = global.document.createElement('input')
+      input.type = 'file'
+      return input.files
+    }
+  },
+  {
+    type: 'ImageData',
+    ctor: true,
+    allowFailure: true,
+    createValue: function (ctor) {
+      return new ctor(1, 1)
+    },
+    test: function (value) {
+      return value.data.length === 4
+    }
+  }
+]
+
+module.exports = function (leveljs, test, testCommon) {
+  var db
+
+  test('setUp', testCommon.setUp)
+  test('open', function (t) {
+    db = leveljs(testCommon.location())
+    db.open(t.end.bind(t))
+  })
+
+  types.forEach(function (item) {
+    var testName = item.name || item.type
+
+    test('structured clone: ' + testName, function (t) {
+      var ctor = item.ctor ? global[item.type] : null
+      var skip = item.allowFailure ? 'pass' : 'fail'
+      var input = item.value
+
+      if (item.ctor && !ctor) {
+        t[skip]('constructor is undefined in this environment')
+        return t.end()
+      }
+
+      if (item.createValue) {
+        try {
+          input = item.createValue(ctor)
+        } catch (err) {
+          t[skip]('constructor is not spec-compliant in this environment')
+          return t.end()
+        }
+      }
+
+      db.put(testName, input, function (err) {
+        if (err && isDataCloneError(err)) {
+          t[skip]('serializing is not supported by the structured clone algorithm of this environment')
+          return t.end()
+        }
+
+        t.notOk(err, 'no put error')
+
+        db.get(testName, { asBuffer: false }, function (err, value) {
+          t.notOk(err, 'no get error')
+
+          if (ctor) {
+            var expected = '[object ' + item.type + ']'
+            var actual = Object.prototype.toString.call(value)
+
+            if (actual === expected) {
+              t.is(actual, expected, 'prototype')
+              t.ok(value instanceof ctor, 'instanceof')
+            } else {
+              t[skip]('deserializing is not supported by the structured clone algorithm of this environment')
+              return t.end()
+            }
+          }
+
+          if (item.test) {
+            t.ok(item.test(value), 'correct value')
+          } else {
+            t.same(value, input, 'correct value')
+          }
+
+          t.end()
+        })
+      })
+    })
+  })
+
+  test('close', function (t) { db.close(t.end.bind(t)) })
+  test('teardown', testCommon.tearDown)
+}

util/is-data-clone-error.js

@@ -0,0 +1,7 @@
+'use strict'
+
+var LEGACY_CODE = 25
+
+module.exports = function (err) {
+  return err.name === 'DataCloneError' || err.code === LEGACY_CODE
+}