make sure properties that throw on their getters are handled properly, some refactoring

Author: ckknight

lib/async-json.js

@@ -52,16 +52,6 @@
 
   function stringifyAux(data, callback, errback, key, counter, context) {
     switch (typeof data) {
-      case "undefined":
-        callback(undefined);
-        break;
-      case "string":
-      case "number":
-        callback(jsonStringify(data));
-        break;
-      case "boolean":
-        callback(data ? "true" : "false");
-        break;
       case "object":
         if (data === null) {
           // why is typeof null === "object"?
@@ -74,10 +64,10 @@
             }, errback);
           } else if (typeof data.toJSON === "function") {
             // used by Date and possibly some others.
-            stringify(data.toJSON(key), callback, errback, key, counter, undefined);
+            callback(jsonStringify(data.toJSON(key)));
           } else if (isPrimitiveConstructor(data.constructor)) {
             // horrible, someone used the new String(), new Number(), or new Boolean() syntax.
-            stringify(data.valueOf(), callback, errback, key, counter, undefined);
+            callback(jsonStringify(data));
           } else if (isArray(data)) {
             internalStringifyArray(data, callback, errback, counter);
           } else {
@@ -100,11 +90,8 @@
           });
         }
         break;
-      case "null":
-        callback("null");
-        break;
       default:
-        callback(jsonStringify(value));
+        callback(jsonStringify(data));
         break;
     }
   }
@@ -178,8 +165,12 @@
     }
 
     function run(start) {
-      for (var i = start; step(i); ++i) {
-        // nothing to do, as step's return value will cause a halt eventually
+      try {
+        for (var i = start; step(i); ++i) {
+          // nothing to do, as step's return value will cause a halt eventually
+        }
+      } catch (e) {
+        errback(e);
       }
     }
 
@@ -254,8 +245,12 @@
     };
 
     function run(start) {
-      for (var i = start; step(i); ++i) {
-        // nothing to do, as step's return value will cause a halt eventually
+      try {
+        for (var i = start; step(i); ++i) {
+          // nothing to do, as step's return value will cause a halt eventually
+        }
+      } catch (e) {
+        errback(e);
       }
     };
 

test/async-json.test.js

@@ -188,6 +188,56 @@ module.exports = {
       }
     }));
   },
+  "object with tainted property": Object.defineProperty ? function(beforeExit) {
+    var obj = {};
+    var error = new Error();
+    Object.defineProperty(obj, 'key', {
+      get: function () {
+        throw error;
+      },
+      enumerable: true
+    })
+    var calls = 0;
+
+    asyncJSON.stringify(obj, function (err) {
+      assert.strictEqual(error, err);
+      ++calls;
+    });
+
+    beforeExit(function() {
+      assert.strictEqual(1, calls);
+    });
+  } : null,
+  "object with tainted property after async": Object.defineProperty ? function(beforeExit) {
+    var obj = {
+      init: function (callback) {
+        process.nextTick(function () {
+          try {
+            callback(null, 'value');
+          } catch (e) {
+            throw new Error("should not reach here");
+          }
+        });
+      }
+    };
+    var error = new Error();
+    Object.defineProperty(obj, 'key', {
+      get: function () {
+        throw error;
+      },
+      enumerable: true
+    })
+    var calls = 0;
+
+    asyncJSON.stringify(obj, function (err) {
+      assert.strictEqual(error, err);
+      ++calls;
+    });
+
+    beforeExit(function() {
+      assert.strictEqual(1, calls);
+    });
+  } : null,
   "lazy functions": function(beforeExit) {
     asyncEquality(beforeExit, function() {
       assert.equal(DEFAULT_THIS, this);
@@ -441,5 +491,14 @@ module.exports = {
     beforeExit(function() {
       assert.strictEqual(1, calls);
     });
+  } : null,
+  "symbols are ignored as keys": typeof Symbol === 'function' ? function(beforeExit) {
+    var obj = {};
+    obj[Symbol('key')] = 'value';
+    asyncEqualityToSync(beforeExit, obj);
+  } : null,
+  "symbols are ignored as keys": typeof Symbol === 'function' ? function(beforeExit) {
+    var obj = { key: Symbol('value') };
+    asyncEqualityToSync(beforeExit, obj);
   } : null
 };