rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.transforms.test.js

@@ -1,1193 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var util = require('util');
-var vows = require('vows');
-var sinon = require('sinon');
-var t = require('../src/server/transforms');
-
-process.env.NODE_ENV = process.env.NODE_ENV || 'test-node-env';
-var rollbar = require('../src/server/rollbar');
-var _ = require('../src/utility');
-
-function CustomError(message, nested) {
-  rollbar.Error.call(this, message, nested);
-}
-util.inherits(CustomError, rollbar.Error);
-
-async function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-async function throwInScriptFile(rollbar, filepath, callback) {
-  setTimeout(function () {
-    var error = require(filepath);
-    error();
-  }, 10);
-  await wait(500);
-  callback(rollbar);
-}
-
-var nodeVersion = (function () {
-  var version = process.versions.node.split('.');
-
-  return [parseInt(version[0]), parseInt(version[1]), parseInt(version[2])];
-})();
-
-var isMinNodeVersion = function (major, minor) {
-  return (
-    nodeVersion[0] > major ||
-    (nodeVersion[0] === major && nodeVersion[1] >= minor)
-  );
-};
-
-vows
-  .describe('transforms')
-  .addBatch({
-    baseData: {
-      options: {
-        defaults: {
-          topic: function () {
-            return rollbar.defaultOptions;
-          },
-          item: {
-            empty: {
-              topic: function (options) {
-                var item = {};
-                t.baseData(item, options, this.callback);
-              },
-              'should have a timestamp': function (err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.notEqual(item.data.timestamp, undefined);
-              },
-              'should have an error level': function (err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.equal(item.data.level, 'error');
-              },
-              'should have some defaults': function (err, item) {
-                assert.ifError(err);
-                var data = item.data;
-                assert.equal(data.environment, process.env.NODE_ENV);
-                assert.equal(data.framework, 'node-js');
-                assert.equal(data.language, 'javascript');
-                assert.ok(data.server);
-                assert.ok(data.server.host);
-                assert.ok(data.server.pid);
-              },
-            },
-            'with values': {
-              topic: function (options) {
-                var item = {
-                  level: 'critical',
-                  framework: 'star-wars',
-                  uuid: '12345',
-                  environment: 'production',
-                  custom: {
-                    one: 'a1',
-                    stuff: 'b2',
-                    language: 'english',
-                  },
-                };
-                t.baseData(item, options, this.callback);
-              },
-              'should have a critical level': function (err, item) {
-                assert.ifError(err);
-                assert.equal(item.data.level, 'critical');
-              },
-              'should have the defaults overriden by the item': function (
-                err,
-                item,
-              ) {
-                assert.ifError(err);
-                assert.equal(item.data.environment, 'production');
-                assert.equal(item.data.framework, 'star-wars');
-                assert.equal(item.data.language, 'javascript');
-                assert.equal(item.data.uuid, '12345');
-              },
-              'should have data from custom': function (err, item) {
-                assert.equal(item.data.one, 'a1');
-                assert.equal(item.data.stuff, 'b2');
-                assert.notEqual(item.data.language, 'english');
-              },
-            },
-          },
-        },
-        'with values': {
-          topic: function () {
-            return _.merge(rollbar.defaultOptions, {
-              payload: {
-                environment: 'payload-prod',
-              },
-              framework: 'opt-node',
-              host: 'opt-host',
-              branch: 'opt-master',
-            });
-          },
-          item: {
-            empty: {
-              topic: function (options) {
-                var item = {};
-                t.baseData(item, options, this.callback);
-              },
-              'should have a timestamp': function (err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.notEqual(item.data.timestamp, undefined);
-              },
-              'should have an error level': function (err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.equal(item.data.level, 'error');
-              },
-              'should have data from options and defaults': function (
-                err,
-                item,
-              ) {
-                assert.ifError(err);
-                var data = item.data;
-                assert.equal(data.environment, 'payload-prod');
-                assert.equal(data.framework, 'opt-node');
-                assert.equal(data.language, 'javascript');
-                assert.ok(data.server);
-                assert.equal(data.server.host, 'opt-host');
-                assert.equal(data.server.branch, 'opt-master');
-                assert.ok(data.server.pid);
-              },
-            },
-            'with values': {
-              topic: function (options) {
-                var item = {
-                  level: 'critical',
-                  environment: 'production',
-                  framework: 'star-wars',
-                  uuid: '12345',
-                  custom: {
-                    one: 'a1',
-                    stuff: 'b2',
-                    language: 'english',
-                  },
-                };
-                t.baseData(item, options, this.callback);
-              },
-              'should have a critical level': function (err, item) {
-                assert.ifError(err);
-                assert.equal(item.data.level, 'critical');
-              },
-              'should have the defaults overriden by the item': function (
-                err,
-                item,
-              ) {
-                assert.ifError(err);
-                assert.equal(item.data.environment, 'production');
-                assert.equal(item.data.framework, 'star-wars');
-                assert.equal(item.data.language, 'javascript');
-                assert.equal(item.data.uuid, '12345');
-              },
-              'should have data from custom': function (err, item) {
-                assert.equal(item.data.one, 'a1');
-                assert.equal(item.data.stuff, 'b2');
-                assert.notEqual(item.data.language, 'english');
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-  .addBatch({
-    addBody: {
-      options: {
-        anything: {
-          topic: function () {
-            return { whatever: 'stuff' };
-          },
-          item: {
-            'with stackInfo': {
-              topic: function (options) {
-                var item = { stackInfo: [{ message: 'hey' }] };
-                t.addBody(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should set the trace_chain': function (err, item) {
-                assert.ok(item.data.body.trace_chain);
-              },
-              'should not set a message': function (err, item) {
-                assert.ok(!item.data.body.message);
-              },
-            },
-            'with no stackInfo': {
-              topic: function (options) {
-                var item = { message: 'hello' };
-                t.addBody(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should not set the trace_chain': function (err, item) {
-                assert.ok(!item.data.body.trace_chain);
-              },
-              'should set a message': function (err, item) {
-                assert.ok(item.data.body.message);
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-  .addBatch({
-    addMessageData: {
-      options: {
-        anything: {
-          topic: function () {
-            return { random: 'stuff' };
-          },
-          item: {
-            'no message': {
-              topic: function (options) {
-                var item = { err: 'stuff', not: 'a message' };
-                t.addMessageData(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should add an empty body': function (err, item) {
-                assert.ok(item.data.body);
-              },
-            },
-            'with a message': {
-              topic: function (options) {
-                var item = { message: 'this is awesome' };
-                t.addMessageData(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should add a body with the message': function (err, item) {
-                assert.equal(item.data.body.message.body, 'this is awesome');
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-  .addBatch({
-    nodeSourceMaps: {
-      'with original source present': {
-        topic: function () {
-          var Rollbar = new rollbar({
-            accessToken: 'abc123',
-            captureUncaught: true,
-            nodeSourceMaps: true,
-          });
-          var queue = Rollbar.client.notifier.queue;
-          Rollbar.addItemStub = sinon.stub(queue, 'addItem');
-
-          throwInScriptFile(
-            Rollbar,
-            '../examples/node-typescript/dist/index',
-            this.callback,
-          );
-        },
-        'should map the stack with context': function (r) {
-          var addItem = r.addItemStub;
-
-          assert.isTrue(addItem.called);
-          if (addItem.called) {
-            var frame = addItem
-              .getCall(0)
-              .args[0].body.trace_chain[0].frames.pop();
-            assert.ok(frame.filename.includes('src/index.ts'));
-            assert.equal(frame.lineno, 10);
-            assert.equal(frame.colno, 22);
-            assert.equal(
-              frame.code,
-              "  var error = <Error> new CustomError('foo');",
-            );
-            assert.equal(frame.context.pre[0], '    }');
-            assert.equal(frame.context.pre[1], '  }');
-            assert.equal(
-              frame.context.pre[2],
-              '  // TypeScript code snippet will include `<Error>`',
-            );
-            assert.equal(frame.context.post[0], '  throw error;');
-            assert.equal(frame.context.post[1], '}');
-
-            var sourceMappingURLs =
-              addItem.getCall(0).args[0].notifier.diagnostic.node_source_maps
-                .source_mapping_urls;
-            var urls = Object.keys(sourceMappingURLs);
-            assert.ok(urls[0].includes('index.js'));
-            assert.ok(sourceMappingURLs[urls[0]].includes('index.js.map'));
-            assert.ok(urls[1].includes('server.transforms.test.js'));
-            assert.ok(sourceMappingURLs[urls[1]].includes('not found'));
-
-            // Node until v12 will have 'timers.js' here.
-            // Node 12 - 14 will have 'internal/timers.js' here.
-            // Starting in v16, this is 'node:internal/timers'.
-            // This assert works for all and is specific enough for this test case.
-            assert.ok(urls[2].includes('timers'));
-            assert.ok(sourceMappingURLs[urls[2]].includes('not found'));
-          }
-          addItem.reset();
-        },
-      },
-    },
-  })
-  .addBatch({
-    nodeSourceMaps: {
-      'using sourcesContent': {
-        topic: function () {
-          var Rollbar = new rollbar({
-            accessToken: 'abc123',
-            captureUncaught: true,
-            nodeSourceMaps: true,
-          });
-          var queue = Rollbar.client.notifier.queue;
-          Rollbar.addItemStub = sinon.stub(queue, 'addItem');
-
-          throwInScriptFile(
-            Rollbar,
-            '../examples/node-dist/index',
-            this.callback,
-          );
-        },
-        'should map the stack with context': function (r) {
-          var addItem = r.addItemStub;
-
-          assert.isTrue(addItem.called);
-          if (addItem.called) {
-            var frame = addItem
-              .getCall(0)
-              .args[0].body.trace_chain[0].frames.pop();
-            assert.ok(frame.filename.includes('src/index.ts'));
-            assert.equal(frame.lineno, 10);
-            assert.equal(frame.colno, 22);
-            assert.equal(
-              frame.code,
-              "  var error = <Error> new CustomError('foo');",
-            );
-            assert.equal(frame.context.pre[0], '    }');
-            assert.equal(frame.context.pre[1], '  }');
-            assert.equal(
-              frame.context.pre[2],
-              '  // TypeScript code snippet will include `<Error>`',
-            );
-            assert.equal(frame.context.post[0], '  throw error;');
-            assert.equal(frame.context.post[1], '}');
-
-            var sourceMappingURLs =
-              addItem.getCall(0).args[0].notifier.diagnostic.node_source_maps
-                .source_mapping_urls;
-            var urls = Object.keys(sourceMappingURLs);
-            assert.ok(urls.length === 1);
-            assert.ok(urls[0].includes('index.js'));
-            assert.ok(sourceMappingURLs[urls[0]].includes('index.js.map'));
-          }
-          addItem.reset();
-        },
-      },
-    },
-  })
-  .addBatch({
-    handleItemWithError: {
-      options: {
-        anything: {
-          topic: function () {
-            return {
-              some: 'stuff',
-              captureIp: true,
-            };
-          },
-          item: {
-            'no error': {
-              topic: function (options) {
-                var item = {
-                  data: { body: { yo: 'hey' } },
-                  message: 'hey',
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should not change the item': function (err, item) {
-                assert.equal(item.data.body.yo, 'hey');
-              },
-            },
-            'with a simple error': {
-              topic: function (options) {
-                var item = {
-                  data: { body: {} },
-                  err: new Error('wookie'),
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should add some data to the trace_chain': function (err, item) {
-                assert.ok(item.stackInfo);
-              },
-            },
-            'with a normal error': {
-              topic: function (options) {
-                var test = function () {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = e;
-                }
-                var item = {
-                  data: { body: {} },
-                  err: err,
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should add some data to the trace_chain': function (err, item) {
-                assert.ok(item.stackInfo);
-              },
-            },
-            'with a nested error': {
-              topic: function (options) {
-                var test = function () {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = new CustomError('nested-message', e);
-                }
-                var item = {
-                  data: { body: {} },
-                  err: err,
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should have the right data in the trace_chain': function (
-                err,
-                item,
-              ) {
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 2);
-                assert.equal(trace_chain[0].exception.class, 'CustomError');
-                assert.equal(
-                  trace_chain[0].exception.message,
-                  'nested-message',
-                );
-                assert.equal(trace_chain[1].exception.class, 'ReferenceError');
-              },
-            },
-            'with a null nested error': {
-              topic: function (options) {
-                var err = new CustomError('With null nested error');
-
-                // Set nested to null for the test
-                err.nested = null;
-
-                var item = {
-                  data: { body: {} },
-                  err: err,
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should have the right data in the trace_chain': function (
-                err,
-                item,
-              ) {
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 1);
-                assert.equal(trace_chain[0].exception.class, 'CustomError');
-              },
-            },
-            'with error context': {
-              topic: function (options) {
-                var test = function () {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = new CustomError('nested-message', e);
-                  e.rollbarContext = { err1: 'nested context' };
-                  err.rollbarContext = { err2: 'error context' };
-                }
-                var item = {
-                  data: { body: {} },
-                  err: err,
-                };
-                options.addErrorContext = true;
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should add the error context': function (err, item) {
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 2);
-                assert.equal(item.data.custom.err1, 'nested context');
-                assert.equal(item.data.custom.err2, 'error context');
-              },
-            },
-            'with an error cause': {
-              topic: function (options) {
-                var test = function () {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = new Error('cause message', { cause: e });
-                  e.rollbarContext = { err1: 'cause context' };
-                  err.rollbarContext = { err2: 'error context' };
-                }
-                var item = {
-                  data: { body: {} },
-                  err: err,
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should have the right data in the trace_chain': function (
-                err,
-                item,
-              ) {
-                // Error cause was introduced in Node 16.9.
-                if (!isMinNodeVersion(16, 9)) return;
-
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 2);
-                assert.equal(trace_chain[0].exception.class, 'Error');
-                assert.equal(trace_chain[0].exception.message, 'cause message');
-                assert.equal(trace_chain[1].exception.class, 'ReferenceError');
-                assert.equal(item.data.custom.err1, 'cause context');
-                assert.equal(item.data.custom.err2, 'error context');
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-  .addBatch({
-    addRequestData: {
-      options: {
-        'without custom addRequestData method': {
-          'without scrub fields': {
-            topic: function () {
-              return {
-                nothing: 'here',
-                captureEmail: true,
-                captureUsername: true,
-                captureIp: true,
-              };
-            },
-            item: {
-              'without a request': {
-                topic: function (options) {
-                  var item = {
-                    data: { body: { message: 'hey' } },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should not change the item': function (err, item) {
-                  assert.equal(item.request, undefined);
-                  assert.equal(item.data.request, undefined);
-                },
-              },
-              'with an empty request object': {
-                topic: function (options) {
-                  var item = {
-                    request: {},
-                    data: { body: { message: 'hey' } },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should not change request object': function (err, item) {
-                  assert.equal(item.request.headers, undefined);
-                },
-              },
-              'with a request': {
-                topic: function (options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345',
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.1',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else',
-                      },
-                      route: { path: '/api/:bork' },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com',
-                      },
-                    },
-                    stuff: 'hey',
-                    data: { other: 'thing' },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function (
-                  err,
-                  item,
-                ) {
-                  assert.ok(item.data.request);
-                },
-                'should set a person based on request user': function (
-                  err,
-                  item,
-                ) {
-                  assert.equal(item.data.person.id, 42);
-                  assert.equal(item.data.person.email, 'fake@example.com');
-                },
-                'should set some fields based on request data': function (
-                  err,
-                  item,
-                ) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/some/endpoint');
-                  assert.equal(r.user_ip, '192.192.192.1');
-                  assert.ok(r.GET);
-
-                  assert.equal(item.data.context, '/api/:bork');
-                },
-              },
-              'with a request for a nested router with a baseURL': {
-                topic: function (options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345',
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      baseUrl: '/nested',
-                      ip: '192.192.192.1',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else',
-                      },
-                      route: { path: '/api/:bork' },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com',
-                      },
-                    },
-                    stuff: 'hey',
-                    data: { other: 'thing' },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function (
-                  err,
-                  item,
-                ) {
-                  assert.ok(item.data.request);
-                },
-                'should set some fields based on request data': function (
-                  err,
-                  item,
-                ) {
-                  var r = item.data.request;
-                  assert.equal(
-                    r.url,
-                    'https://example.com/nested/some/endpoint',
-                  );
-                  assert.equal(item.data.context, '/nested/api/:bork');
-                },
-              },
-              'with a request like from hapi': {
-                topic: function (options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345',
-                      },
-                      protocol: 'https',
-                      url: {
-                        protocol: null,
-                        slashes: null,
-                        auth: null,
-                        host: null,
-                        port: null,
-                        hostname: null,
-                        hash: null,
-                        search: '',
-                        query: {},
-                        pathname: '/some/endpoint',
-                        path: '/some/endpoint',
-                        href: '/some/endpoint',
-                      },
-                      ip: '192.192.192.1',
-                      method: 'POST',
-                      payload: {
-                        token: 'abc123',
-                        something: 'else',
-                      },
-                      route: { path: '/api/:bork' },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com',
-                      },
-                    },
-                    stuff: 'hey',
-                    data: { other: 'thing' },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function (
-                  err,
-                  item,
-                ) {
-                  assert.ok(item.data.request);
-                },
-                'should set a person based on request user': function (
-                  err,
-                  item,
-                ) {
-                  assert.equal(item.data.person.id, 42);
-                  assert.equal(item.data.person.email, 'fake@example.com');
-                },
-                'should set some fields based on request data': function (
-                  err,
-                  item,
-                ) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/some/endpoint');
-                  assert.equal(r.user_ip, '192.192.192.1');
-                  assert.ok(!r.GET);
-                  assert.ok(r.POST);
-
-                  assert.equal(item.data.context, '/api/:bork');
-                },
-              },
-              'with a request with an array body': {
-                topic: function (options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345',
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.1',
-                      method: 'POST',
-                      body: [
-                        {
-                          token: 'abc123',
-                          something: 'else',
-                        },
-                        'otherStuff',
-                      ],
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com',
-                      },
-                    },
-                    stuff: 'hey',
-                    data: { other: 'thing' },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function (
-                  err,
-                  item,
-                ) {
-                  assert.ok(item.data.request);
-                },
-                'should set a person based on request user': function (
-                  err,
-                  item,
-                ) {
-                  assert.equal(item.data.person.id, 42);
-                  assert.equal(item.data.person.email, 'fake@example.com');
-                },
-                'should set some fields based on request data': function (
-                  err,
-                  item,
-                ) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/some/endpoint');
-                  assert.equal(r.user_ip, '192.192.192.1');
-                  assert.ok(r.POST);
-                  assert.equal(r.POST['0'].something, 'else');
-                  assert.equal(r.POST['1'], 'otherStuff');
-                },
-              },
-            },
-          },
-          'with scrub fields': {
-            topic: function () {
-              return {
-                scrubHeaders: ['x-auth-token'],
-                scrubFields: ['passwd', 'access_token', 'request.cookie'],
-              };
-            },
-            item: {
-              'with a request': {
-                topic: function (options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345',
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.192',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else',
-                      },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com',
-                      },
-                    },
-                    stuff: 'hey',
-                    data: { other: 'thing' },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function (
-                  err,
-                  item,
-                ) {
-                  assert.ok(item.data.request);
-                },
-              },
-            },
-          },
-        },
-        'with custom addRequestData': {
-          'with scrub fields': {
-            topic: function () {
-              var customFn = function (i, r) {
-                assert.equal(i.stuff, undefined);
-                assert.equal(i.other, 'thing');
-                i.myRequest = { body: r.body.token };
-              };
-              return {
-                captureIp: true,
-                addRequestData: customFn,
-                scrubFields: [
-                  'passwd',
-                  'access_token',
-                  'token',
-                  'request.cookie',
-                ],
-              };
-            },
-            item: {
-              'with a request': {
-                topic: function (options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345',
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.192',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else',
-                      },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com',
-                      },
-                    },
-                    stuff: 'hey',
-                    data: { other: 'thing' },
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function (err, item) {
-                  assert.ifError(err);
-                },
-                'should do what the function does': function (err, item) {
-                  assert.equal(item.data.request, undefined);
-                  assert.equal(item.data.myRequest.body, 'abc123');
-                },
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-  .addBatch({
-    scrubPayload: {
-      options: {
-        'without scrub fields': {
-          topic: function () {
-            return rollbar.defaultOptions;
-          },
-          item: {
-            topic: function (options) {
-              var item = {
-                data: {
-                  body: {
-                    message: 'hey',
-                    password: '123',
-                    secret: { stuff: 'here' },
-                  },
-                },
-              };
-              t.scrubPayload(item, options, this.callback);
-            },
-            'should not error': function (err, item) {
-              assert.ifError(err);
-            },
-            'should not scrub okay keys': function (err, item) {
-              assert.equal(item.data.body.message, 'hey');
-            },
-            'should scrub key/value based on defaults': function (err, item) {
-              assert.matches(item.data.body.password, /\*+/);
-              assert.matches(item.data.body.secret, /\*+/);
-            },
-          },
-        },
-        'with scrub fields': {
-          topic: function () {
-            return {
-              captureIp: true,
-              scrubHeaders: ['x-auth-token'],
-              scrubFields: [
-                'passwd',
-                'access_token',
-                'request.cookie',
-                'sauce',
-              ],
-              scrubRequestBody: true,
-            };
-          },
-          item: {
-            'with a request': {
-              topic: function (options) {
-                var item = {
-                  request: {
-                    headers: {
-                      host: 'example.com',
-                      'x-auth-token': '12345',
-                    },
-                    protocol: 'https',
-                    url: '/some/endpoint',
-                    ip: '192.192.192.192',
-                    method: 'GET',
-                    body: {
-                      token: 'abc123',
-                      something: 'else',
-                    },
-                    user: {
-                      id: 42,
-                      email: 'fake@example.com',
-                    },
-                  },
-                  stuff: 'hey',
-                  data: {
-                    other: 'thing',
-                    sauce: 'secrets',
-                    someParams: 'foo=okay&passwd=iamhere',
-                  },
-                };
-                t.addRequestData(
-                  item,
-                  options,
-                  function (e, i) {
-                    if (e) {
-                      this.callback(e);
-                      return;
-                    }
-                    t.scrubPayload(i, options, this.callback);
-                  }.bind(this),
-                );
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should have a request object inside data': function (err, item) {
-                assert.ok(item.data.request);
-              },
-              'should scrub based on the options': function (err, item) {
-                var r = item.data.request;
-                assert.equal(r.GET.token, 'abc123');
-                assert.match(r.headers['x-auth-token'], /\*+/);
-                assert.equal(r.headers['host'], 'example.com');
-                assert.match(item.data.sauce, /\*+/);
-                assert.equal(item.data.other, 'thing');
-                assert.match(item.data.someParams, /foo=okay&passwd=\*+/);
-              },
-            },
-            'with a json request body': {
-              topic: function (options) {
-                var requestBody = JSON.stringify({
-                  token: 'abc123',
-                  something: 'else',
-                  passwd: '123456',
-                });
-                var item = {
-                  request: {
-                    headers: {
-                      host: 'example.com',
-                      'content-type': 'application/json',
-                      'x-auth-token': '12345',
-                    },
-                    protocol: 'https',
-                    url: '/some/endpoint',
-                    ip: '192.192.192.192',
-                    method: 'GET',
-                    body: requestBody,
-                    user: {
-                      id: 42,
-                      email: 'fake@example.com',
-                    },
-                  },
-                  stuff: 'hey',
-                  data: {
-                    other: 'thing',
-                    sauce: 'secrets',
-                    someParams: 'foo=okay&passwd=iamhere',
-                  },
-                };
-                t.addRequestData(
-                  item,
-                  options,
-                  function (e, i) {
-                    if (e) {
-                      this.callback(e);
-                      return;
-                    }
-                    t.scrubPayload(i, options, this.callback);
-                  }.bind(this),
-                );
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should have a request object inside data': function (err, item) {
-                assert.ok(item.data.request);
-              },
-              'should scrub based on the options': function (err, item) {
-                var r = item.data.request;
-                assert.match(r.headers['x-auth-token'], /\*+/);
-                assert.equal(r.headers['host'], 'example.com');
-                assert.match(item.data.sauce, /\*+/);
-                assert.equal(item.data.other, 'thing');
-                assert.match(item.data.someParams, /foo=okay&passwd=\*+/);
-
-                var requestBody = JSON.parse(item.data.request.body);
-                assert.match(requestBody.passwd, /\*+/);
-              },
-            },
-            'with a bad json request body': {
-              topic: function (options) {
-                var requestBody = 'not valid json';
-                var item = {
-                  request: {
-                    headers: {
-                      'content-type': 'application/json',
-                    },
-                    protocol: 'https',
-                    url: '/some/endpoint',
-                    ip: '192.192.192.192',
-                    method: 'GET',
-                    body: requestBody,
-                  },
-                };
-                t.addRequestData(
-                  item,
-                  options,
-                  function (e, i) {
-                    if (e) {
-                      this.callback(e);
-                      return;
-                    }
-                    t.scrubPayload(i, options, this.callback);
-                  }.bind(this),
-                );
-              },
-              'should not error': function (err, item) {
-                assert.ifError(err);
-              },
-              'should have a request object inside data': function (err, item) {
-                assert.ok(item.data.request);
-              },
-              'should delete the body and add a diagnostic error': function (
-                err,
-                item,
-              ) {
-                var requestBody = JSON.parse(item.data.request.body);
-                assert.equal(requestBody, null);
-                assert.match(
-                  item.data.request.error,
-                  /request.body parse failed/,
-                );
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-  .export(module, { error: false });