init

node_modules/stack-chain/test/produce.js

@@ -0,0 +1,44 @@
+
+// Produces an error with `level` deept in the call stack
+exports.deepStack = function deepStack(curr, top, callback) {
+  if (curr === top) {
+    callback();
+  } else {
+    deepStack(curr + 1, top, callback);
+  }
+};
+
+exports.real = function produceError(level) {
+  var stack;
+  var limit = Error.stackTraceLimit;
+
+  exports.deepStack(0, level, function () {
+    Error.stackTraceLimit = level;
+
+    var error = new Error('trace');
+        error.test = true;
+    stack = error.stack;
+
+    Error.stackTraceLimit = limit;
+  });
+
+  return stack || 'Error: trace';
+};
+
+exports.fake = function(input) {
+  var output = [];
+
+  for (var i = 0, l = input.length; i < l; i++) {
+    output.push(input[i].replace('{where}', module.filename));
+  }
+
+  return output.join('\n');
+};
+
+exports.convert = function (callSites) {
+  var lines = [];
+  for (var i = 0; i < callSites.length; i++) {
+    lines.push("    at " + callSites[i].toString());
+  }
+  return lines.join('\n');
+};

node_modules/stack-chain/test/simple/callSite-function.js

@@ -0,0 +1,121 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var produce = require('../produce.js');
+
+Error.stackTraceLimit = Infinity;
+
+test("stack extend part", function (t) {
+  var extend = function (error, frames) {
+    frames.splice(1, 0, 'EXTEND', 'FILTER ME');
+    return frames;
+  };
+
+  var filter = function (error, frames) {
+    return frames.filter(function (callSite) {
+      return callSite !== 'FILTER ME';
+    });
+  };
+
+  var callSites = function (level, options) {
+    var limit = Error.stackTraceLimit;
+    var callSites;
+    produce.deepStack(0, level, function () {
+      Error.stackTraceLimit = level;
+      callSites = chain.callSite(options);
+      Error.stackTraceLimit = limit;
+    });
+
+    return callSites.slice(1, Infinity);
+  };
+
+  t.test("callSite method matches simple case property length", function (t) {
+    var method = chain.callSite();
+    var propery = chain.originalCallSite(new Error());
+    t.strictEqual(method.length, propery.length);
+
+    // The other stuff still works
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("pretest: toString of callSites array", function (t) {
+    t.equal(produce.convert(callSites(3)), produce.fake([
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("callSite with extend", function (t) {
+    chain.extend.attach(extend);
+    var textA = produce.convert(callSites(3, { extend: true }));
+    var textB = produce.convert(callSites(3));
+    chain.extend.deattach(extend);
+
+    t.equal(textA, produce.fake([
+      '    at EXTEND',
+      '    at FILTER ME',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.equal(textB, produce.fake([
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("callSite with extend and filter", function (t) {
+    chain.extend.attach(extend);
+    chain.filter.attach(filter);
+    var textA = produce.convert(callSites(3, { extend: true, filter: true }));
+    var textB = produce.convert(callSites(3, { filter: true }));
+    chain.filter.deattach(filter);
+    chain.extend.deattach(extend);
+
+    t.equal(textA, produce.fake([
+      '    at EXTEND',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.equal(textB, produce.fake([
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("callSite with extend and filter and slice", function (t) {
+    chain.extend.attach(extend);
+    chain.filter.attach(filter);
+    var textA = produce.convert(callSites(3, { extend: true, filter: true, slice: 1 }));
+    var textB = produce.convert(callSites(3, { slice: 1 }));
+    chain.filter.deattach(filter);
+    chain.extend.deattach(extend);
+
+    t.equal(textA, produce.fake([
+      '    at EXTEND',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.equal(textB, produce.fake([
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/callSite-property.js

@@ -0,0 +1,48 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var produce = require('../produce.js');
+
+Error.stackTraceLimit = Infinity;
+
+test("stack extend part", function (t) {
+  var modify = function (text) {
+    return function (error, frames) {
+      if (error.test) {
+        frames.push(text);
+      }
+
+      return frames;
+    };
+  };
+
+  t.test("no extend modifier attached", function (t) {
+    var error = new Error();
+        error.test = error;
+
+    var original = chain.originalCallSite(error).length;
+    var mutated = chain.mutatedCallSite(error).length;
+    t.strictEqual(mutated, original);
+
+    t.end();
+  });
+
+  t.test("attach modifier", function (t) {
+    var error = new Error();
+        error.test = error;
+
+    var wonderLand = modify("wonder land");
+
+    chain.extend.attach(wonderLand);
+
+    var original = chain.originalCallSite(error).length;
+    var mutated = chain.mutatedCallSite(error).length;
+    t.strictEqual(mutated, original + 1);
+
+    chain.extend.deattach(wonderLand);
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/conflict-format-delayed-circular.js

@@ -0,0 +1,86 @@
+
+var test = require("tap").test;
+var defaultFormater = require('../../format.js');
+var produce = require('../produce.js');
+
+var chain = require('../../');
+
+test("set Error.prepareStackTrace uses stack-chain formater", function (t) {
+  // Save original formatter
+  var restore = Error.prepareStackTrace;
+
+  // Overwrite formatter
+  Error.prepareStackTrace = function (error, frames) {
+    if (error.test) {
+      Object.defineProperty(error, '__some_secret', {
+        value: 'you can\'t compare pain.'
+      });
+    }
+
+    // Maintain .stack format
+    return restore(error, frames);
+  };
+
+  // Prope the error using custom prepareStackTrace
+  var testError = new Error();
+  testError.test = true;
+  testError.stack;
+  t.equal(testError.__some_secret, 'you can\'t compare pain.');
+
+  // Restore
+  Error.prepareStackTrace = restore;
+
+  t.equal(produce.real(3), produce.fake([
+    'Error: trace',
+    '    at {where}:18:17',
+    '    at deepStack ({where}:5:5)',
+    '    at deepStack ({where}:7:5)'
+  ]));
+
+  t.end();
+});
+
+test("set Error.prepareStackTrace uses other formater", function (t) {
+  // Another module sets up a formater
+  Error.prepareStackTrace = function () {
+    return 'custom';
+  };
+
+  // Save original formatter
+  var restore = Error.prepareStackTrace;
+
+  // Overwrite formatter
+  Error.prepareStackTrace = function (error, frames) {
+    if (error.test) {
+      Object.defineProperty(error, '__some_secret', {
+        value: 'you can\'t compare pain.'
+      });
+    }
+
+    // Maintain .stack format
+    return restore(error, frames);
+  };
+
+  // Prope the error using custom prepareStackTrace
+  var testError = new Error();
+  testError.test = true;
+  testError.stack;
+  t.equal(testError.__some_secret, 'you can\'t compare pain.');
+
+  // Restore
+  Error.prepareStackTrace = restore;
+
+  t.equal(produce.real(3), 'custom');
+
+  // Perform an actual restore of the formater, to prevent test conflicts
+  chain.format.restore();
+
+  t.equal(produce.real(3), produce.fake([
+    'Error: trace',
+    '    at {where}:18:17',
+    '    at deepStack ({where}:5:5)',
+    '    at deepStack ({where}:7:5)'
+  ]));
+
+  t.end();
+});

node_modules/stack-chain/test/simple/conflict-format-delayed.js

@@ -0,0 +1,112 @@
+
+var test = require("tap").test;
+var defaultFormater = require('../../format.js');
+var produce = require('../produce.js');
+
+var chain = require('../../');
+
+// Set a formater after stack-chain is required
+function prepareStackTrace(error, frames) {
+  if (error.test) {
+    var lines = [];
+        lines.push(error.toString());
+
+    for (var i = 0, l = frames.length; i < l; i++) {
+        lines.push(frames[i].getFunctionName());
+    }
+
+    return lines.join("\n");
+  }
+
+  return defaultFormater(error, frames);
+}
+
+test("set Error.prepareStackTrace after require", function (t) {
+  t.test("set prepareStackTrace", function (t) {
+    Error.prepareStackTrace = prepareStackTrace;
+    t.end();
+  });
+
+  t.test("default formatter replaced", function (t) {
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '',
+      'deepStack',
+      'deepStack'
+    ]));
+
+    t.end();
+  });
+
+  t.test("restore default formater", function (t) {
+    chain.format.restore();
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.end();
+});
+
+test("set Error.prepareStackTrace after require to undefined", function (t) {
+  t.test("set prepareStackTrace", function (t) {
+    Error.prepareStackTrace = prepareStackTrace;
+    t.end();
+  });
+
+  t.test("default formatter replaced", function (t) {
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '',
+      'deepStack',
+      'deepStack'
+    ]));
+
+    t.end();
+  });
+
+  t.test("restore default formater", function (t) {
+    Error.prepareStackTrace = undefined;
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.end();
+});
+
+test("set Error.prepareStackTrace after require to itself", function (t) {
+  t.test("default formatter replaced", function (t) {
+    var old = Error.prepareStackTrace;
+
+    Error.prepareStackTrace = function () {
+      return 'custom';
+    };
+    t.equal(new Error().stack, 'custom');
+
+    Error.prepareStackTrace = old;
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/conflict-format-existing.js

@@ -0,0 +1,50 @@
+
+var test = require("tap").test;
+var defaultFormater = require('../../format.js');
+var produce = require('../produce.js');
+
+// Set a formater before stack-chain is required
+Error.prepareStackTrace = function (error, frames) {
+  if (error.test) {
+    var lines = [];
+        lines.push(error.toString());
+
+    for (var i = 0, l = frames.length; i < l; i++) {
+        lines.push(frames[i].getFunctionName());
+    }
+
+    return lines.join("\n");
+  }
+
+  return defaultFormater(error, frames);
+};
+
+var chain = require('../../');
+
+test("set Error.prepareStackTrace before require", function (t) {
+  t.test("default formatter replaced", function (t) {
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '',
+      'deepStack',
+      'deepStack'
+    ]));
+
+    t.end();
+  });
+
+  t.test("restore default formater", function (t) {
+    chain.format.restore();
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/conflict-version-first.js

@@ -0,0 +1,8 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+
+test("no other copy", function (t) {
+  t.strictEqual(global._stackChain, chain);
+  t.end();
+});

node_modules/stack-chain/test/simple/conflict-version-match.js

@@ -0,0 +1,10 @@
+
+var test = require("tap").test;
+
+var first = global._stackChain = { version: require('../../package.json').version };
+var chain = require('../../');
+
+test("same version but copies", function (t) {
+  t.strictEqual(chain, first);
+  t.end();
+});

node_modules/stack-chain/test/simple/conflict-version-mismatch.js

@@ -0,0 +1,13 @@
+
+var test = require("tap").test;
+
+global._stackChain = { version: "unlikely" };
+
+test("diffrent version but copies", function (t) {
+  try {
+    require('../../');
+  } catch (e) {
+    t.equal(e.message, 'Conflicting version of stack-chain found');
+    t.end();
+  }
+});

node_modules/stack-chain/test/simple/extend.js

@@ -0,0 +1,84 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var produce = require('../produce.js');
+
+test("stack extend part", function (t) {
+  var modify = function (text) {
+    return function (error, frames) {
+      if (error.test) {
+        frames.splice(1, 0, text);
+      }
+
+      return frames;
+    };
+  };
+
+  t.test("no extend modifier attached", function (t) {
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("attach modifier", function (t) {
+    var wonderLand = modify("wonder land");
+
+    chain.extend.attach(wonderLand);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at wonder land',
+      '    at deepStack ({where}:5:5)'
+    ]));
+
+    chain.extend.deattach(wonderLand);
+
+    t.end();
+  });
+
+  t.test("deattach modifier", function (t) {
+    var wonderLand = modify("wonder land");
+
+    chain.extend.attach(wonderLand);
+    t.equal(chain.extend.deattach(wonderLand), true);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.equal(chain.extend.deattach(wonderLand), false);
+
+    t.end();
+  });
+
+  t.test("execution order", function (t) {
+    var wonderLand = modify("wonder land");
+    var outerSpace = modify("outer space");
+
+    chain.extend.attach(wonderLand);
+    chain.extend.attach(outerSpace);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at outer space',
+      '    at wonder land'
+    ]));
+
+    chain.extend.deattach(wonderLand);
+    chain.extend.deattach(outerSpace);
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/filter.js

@@ -0,0 +1,72 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var produce = require('../produce.js');
+
+test("stack filter part", function (t) {
+  var filter = function (error, frames) {
+    if (error.test) {
+      frames.splice(0, 1);
+    }
+
+    return frames;
+  };
+
+  t.test("no extend modifier attached", function (t) {
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("attach modifier", function (t) {
+    chain.extend.attach(filter);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    chain.extend.deattach(filter);
+
+    t.end();
+  });
+
+  t.test("deattach modifier", function (t) {
+    chain.extend.attach(filter);
+    t.equal(chain.extend.deattach(filter), true);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.equal(chain.extend.deattach(filter), false);
+
+    t.end();
+  });
+
+  t.test("execution order", function (t) {
+    chain.extend.attach(filter);
+    chain.extend.attach(filter);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    chain.extend.deattach(filter);
+    chain.extend.deattach(filter);
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/format-replace.js

@@ -0,0 +1,64 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var defaultFormater = require('../../format.js');
+var produce = require('../produce.js');
+
+test("stack format part", function (t) {
+  var format = function (error, frames) {
+    if (error.test) {
+      var lines = [];
+          lines.push(error.toString());
+
+      for (var i = 0, l = frames.length; i < l; i++) {
+          lines.push(frames[i].getFunctionName());
+      }
+
+      return lines.join("\n");
+    }
+
+    return defaultFormater(error, frames);
+  };
+
+  t.test("no formatter set", function (t) {
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.test("default formatter replaced", function (t) {
+    chain.format.replace(format);
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '',
+      'deepStack',
+      'deepStack'
+    ]));
+
+    chain.format.restore();
+
+    t.end();
+  });
+
+  t.test("restore default formater", function (t) {
+    chain.format.replace(format);
+    chain.format.restore();
+
+    t.equal(produce.real(3), produce.fake([
+      'Error: trace',
+      '    at {where}:18:17',
+      '    at deepStack ({where}:5:5)',
+      '    at deepStack ({where}:7:5)'
+    ]));
+
+    t.end();
+  });
+
+  t.end();
+});

node_modules/stack-chain/test/simple/format-tostring-non-generic.js

@@ -0,0 +1,19 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var produce = require('../produce.js');
+
+// See issue https://github.com/AndreasMadsen/stack-chain/issues/12 for
+// a detailed explaination.
+
+test("formatter works for non-generic (non-safe) toString", function (t) {
+  var base = function () {}
+  base.toString = base.toString // sets base.toString to base[[proto]].toString
+  Object.setPrototypeOf(base, {}); // sets base[[proto]] = {}
+
+  var error = Object.create(base); // wrap base using prototype chain
+  Error.captureStackTrace(error); // prepear error.stack
+
+  t.equal(error.stack.split('\n').length, 11);
+  t.end();
+});

node_modules/stack-chain/test/simple/non-extensible-errors.js

@@ -0,0 +1,29 @@
+var test = require("tap").test;
+var chain = require('../../');
+
+test("non extensible Error objects don't throw", function(t) {
+  var error = new Error("don't extend me");
+  Object.preventExtensions(error)
+  t.doesNotThrow(function() {
+    error.stack;
+  });
+  t.end();
+});
+
+test('stack is correct on non extensible error object', function (t) {
+  var error = new Error("don't extend me");
+  Object.preventExtensions(error);
+
+  chain.format.replace(function () {
+    return 'good';
+  });
+
+  try {
+    t.equal(error.stack, 'good');
+  } catch (e) { t.ifError(e); }
+
+  chain.format.restore();
+
+  t.end();
+});
+

node_modules/stack-chain/test/simple/order.js

@@ -0,0 +1,40 @@
+
+var test = require("tap").test;
+var chain = require('../../');
+var produce = require('../produce.js');
+
+test("modifier execution order", function (t) {
+  var filter = function (error, frames) {
+    if (error.test) {
+      frames.splice(0, 1);
+    }
+
+    return frames;
+  };
+
+  var modify = function (error, frames) {
+    if (error.test) {
+      frames.splice(1, 0, "wonder land");
+    }
+
+    return frames;
+  };
+
+  chain.filter.attach(filter);
+  chain.extend.attach(modify);
+  chain.extend.attach(modify);
+
+  t.equal(produce.real(4), produce.fake([
+    'Error: trace',
+    '    at wonder land',
+    '    at wonder land',
+    '    at deepStack ({where}:5:5)',
+    '    at deepStack ({where}:7:5)'
+  ]));
+
+  chain.filter.deattach(filter);
+  chain.extend.deattach(modify);
+  chain.extend.deattach(modify);
+
+  t.end();
+});

node_modules/stack-chain/test/simple/uglify.js

@@ -0,0 +1,12 @@
+
+var test = require("tap").test;
+var uglify = require("uglify-js");
+var path = require("path");
+
+test("can be uglified", function (t) {
+  var files = ['format.js', 'index.js', 'stack-chain.js'].map(function (filename) {
+    return path.resolve(__dirname, '../../' + filename);
+  });
+  uglify.minify(files);
+  t.end()
+});