rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.rollbar.test.js

@@ -1,728 +0,0 @@
-'use strict';
-
-var assert = require('assert');
-var vows = require('vows');
-var sinon = require('sinon');
-
-process.env.NODE_ENV = process.env.NODE_ENV || 'test-node-env';
-var Rollbar = require('../src/server/rollbar');
-
-const DUMMY_TRACE_ID = 'some-trace-id';
-const DUMMY_SPAN_ID = 'some-span-id';
-
-const ValidOpenTracingTracerStub = {
-  scope: () => {
-    return {
-      active: () => {
-        return {
-          setTag: () => {},
-          context: () => {
-            return {
-              toTraceId: () => DUMMY_TRACE_ID,
-              toSpanId: () => DUMMY_SPAN_ID,
-            };
-          },
-        };
-      },
-    };
-  },
-};
-
-const InvalidOpenTracingTracerStub = {
-  foo: () => {},
-};
-
-function TestClientGen() {
-  var TestClient = function () {
-    this.notifier = {
-      addTransform: function () {
-        return this;
-      },
-    };
-    this.queue = {
-      addPredicate: function () {
-        return this;
-      },
-    };
-    this.logCalls = [];
-    var logs = 'log,debug,info,warn,warning,error,critical'.split(',');
-    for (var i = 0, len = logs.length; i < len; i++) {
-      var fn = logs[i].slice(0);
-      this[fn] = function (fn, item) {
-        this.logCalls.push({ func: fn, item: item });
-      }.bind(this, fn);
-    }
-    this.buildJsonPayload = function (obj) {
-      this.logCalls.push({ item: obj });
-    };
-    this.sendJsonPayload = function (json) {
-      this.logCalls.push({ item: json });
-    };
-    this.clearLogCalls = function () {
-      this.logCalls = [];
-    };
-    this.tracer = ValidOpenTracingTracerStub;
-  };
-
-  return TestClient;
-}
-
-async function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-async function nodeReject(rollbar, callback) {
-  Promise.reject(new Error('node reject'));
-  await wait(500);
-  callback(rollbar);
-}
-
-async function nodeThrow(rollbar, callback) {
-  setTimeout(function () {
-    throw new Error('node error');
-  }, 10);
-  await wait(500);
-  callback(rollbar);
-}
-
-vows
-  .describe('rollbar')
-  .addBatch({
-    constructor: {
-      'with accessToken': {
-        topic: function () {
-          return new Rollbar('abc123');
-        },
-        'should have log method': function (r) {
-          assert.isFunction(r.log);
-        },
-        'should have error method': function (r) {
-          assert.isFunction(r.error);
-        },
-        'should have buildJsonPayload method': function (r) {
-          assert.isFunction(r.buildJsonPayload);
-        },
-        'should have sendJsonPayload method': function (r) {
-          assert.isFunction(r.sendJsonPayload);
-        },
-        'should have accessToken in options': function (r) {
-          assert.equal('abc123', r.options.accessToken);
-        },
-      },
-      'with options': {
-        topic: function () {
-          return new Rollbar({ accessToken: 'abc123' });
-        },
-        'should have log method': function (r) {
-          assert.isFunction(r.log);
-        },
-        'should have error method': function (r) {
-          assert.isFunction(r.error);
-        },
-        'should have accessToken in options': function (r) {
-          assert.equal('abc123', r.options.accessToken);
-        },
-        'should set environment based on default': function (r) {
-          assert.equal(process.env.NODE_ENV, r.options.environment);
-        },
-      },
-      'with more options': {
-        topic: function () {
-          return new Rollbar({
-            accessToken: 'abc123',
-            environment: 'fake-env',
-          });
-        },
-        'should have log method': function (r) {
-          assert.isFunction(r.log);
-        },
-        'should have error method': function (r) {
-          assert.isFunction(r.error);
-        },
-        'should have accessToken in options': function (r) {
-          assert.equal('abc123', r.options.accessToken);
-        },
-        'should set environment based on options': function (r) {
-          assert.equal('fake-env', r.options.environment);
-        },
-        'should set configured options': function (r) {
-          assert.equal('fake-env', r.options._configuredOptions.environment);
-        },
-      },
-      'with deprecated options': {
-        topic: function () {
-          return new Rollbar({
-            hostWhiteList: ['foo'],
-            hostBlackList: ['bar'],
-          });
-        },
-        'should replace options': function (r) {
-          assert.equal(r.options.hostWhiteList, undefined);
-          assert.equal(r.options.hostBlackList, undefined);
-          assert.equal(r.options.hostSafeList, 'foo');
-          assert.equal(r.options.hostBlockList, 'bar');
-        },
-      },
-      'with valid tracer': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-            tracer: ValidOpenTracingTracerStub,
-          });
-          return rollbar;
-        },
-        'should configure tracer': function (r) {
-          assert.ok(typeof r.client.tracer === 'object');
-        },
-      },
-      'with invalid tracer': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-            tracer: InvalidOpenTracingTracerStub,
-          });
-          return rollbar;
-        },
-        'should configure tracer': function (r) {
-          assert.equal(null, r.client.tracer);
-        },
-      },
-    },
-    configure: {
-      'with updated options': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-          });
-          rollbar.configure({ captureUncaught: false, environment: 'new-env' });
-          return rollbar;
-        },
-        'should set configured options': function (r) {
-          assert.equal('new-env', r.options._configuredOptions.environment);
-          assert.equal(false, r.options._configuredOptions.captureUncaught);
-        },
-      },
-      'with deprecated options': {
-        topic: function () {
-          var rollbar = new Rollbar({ captureUncaught: true });
-          rollbar.configure({
-            hostWhiteList: ['foo'],
-            hostBlackList: ['bar'],
-          });
-          return rollbar;
-        },
-        'should replace options': function (r) {
-          assert.equal(r.options.hostWhiteList, undefined);
-          assert.equal(r.options.hostBlackList, undefined);
-          assert.equal(r.options.hostSafeList, 'foo');
-          assert.equal(r.options.hostBlockList, 'bar');
-        },
-      },
-      'with valid tracer': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-          });
-          rollbar.configure({ tracer: ValidOpenTracingTracerStub });
-          return rollbar;
-        },
-        'should configure tracer': function (r) {
-          assert.equal(ValidOpenTracingTracerStub, r.client.tracer);
-        },
-      },
-      'with invalid tracer': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-          });
-          rollbar.configure({ tracer: InvalidOpenTracingTracerStub });
-          return rollbar;
-        },
-        'should configure tracer': function (r) {
-          assert.equal(null, r.client.tracer);
-        },
-      },
-    },
-    addTracingInfo: {
-      'with valid tracer': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-            tracer: ValidOpenTracingTracerStub,
-          });
-          return rollbar;
-        },
-        'should add trace ID and span ID to custom field on item if no custom field set':
-          function (r) {
-            const item = { uuid: 'some-uuid', custom: null };
-            r.client._addTracingInfo(item);
-            assert.equal(DUMMY_TRACE_ID, item.custom.opentracing_trace_id);
-            assert.equal(DUMMY_SPAN_ID, item.custom.opentracing_span_id);
-          },
-        'should add trace ID and span ID to custom field on item even if already has some custom fields':
-          function (r) {
-            const item = { uuid: 'some-uuid', custom: { foo: 'foo' } };
-            r.client._addTracingInfo(item);
-            assert.equal(DUMMY_TRACE_ID, item.custom.opentracing_trace_id);
-            assert.equal(DUMMY_SPAN_ID, item.custom.opentracing_span_id);
-            assert.equal('foo', item.custom.foo);
-          },
-      },
-      'with invalid tracer': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            captureUncaught: true,
-            environment: 'fake-env',
-            tracer: InvalidOpenTracingTracerStub,
-          });
-          return rollbar;
-        },
-        'should add trace ID and span ID to custom field on item': function (
-          r,
-        ) {
-          const item = { uuid: 'some-uuid', custom: {} };
-          r.client._addTracingInfo(item);
-          assert.equal(undefined, item.custom.opentracing_trace_id);
-          assert.equal(undefined, item.custom.opentracing_span_id);
-        },
-      },
-    },
-    log: {
-      topic: function () {
-        var client = new (TestClientGen())();
-        var rollbar = new Rollbar({ accessToken: 'abc123' }, client);
-        return rollbar;
-      },
-      message: {
-        'with unordered options': {
-          'should work with custom, request, callback, message ': function (r) {
-            var message = 'hello';
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            var request = { method: 'GET' };
-            var custom = { a: 1, b: 2 };
-            r.log(custom, request, callback, message);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-            assert.equal(item.request, request);
-            assert.deepStrictEqual(item.custom, custom);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-        },
-        'with old option ordering': {
-          'should work': function (r) {
-            var message = 'hello';
-            r.log(message);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-          },
-          'should work with callback': function (r) {
-            var message = 'hello';
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            r.log(message, callback);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-          'should work with request': function (r) {
-            var message = 'hello';
-            var request = { method: 'GET' };
-            r.log(message, request);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-            assert.equal(item.request, request);
-          },
-          'should work with request and callback': function (r) {
-            var message = 'hello';
-            var request = { method: 'GET' };
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            r.log(message, request, callback);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-            assert.equal(item.request, request);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-          'should work with request and custom': function (r) {
-            var message = 'hello';
-            var request = { method: 'GET' };
-            var custom = { a: 1, b: 2 };
-            r.log(message, request, custom);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-            assert.equal(item.request, request);
-            assert.deepStrictEqual(item.custom, custom);
-          },
-          'should work with request and custom and callback': function (r) {
-            var message = 'hello';
-            var request = { method: 'GET' };
-            var custom = { a: 1, b: 2 };
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            r.log(message, request, custom, callback);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.message, message);
-            assert.equal(item.request, request);
-            assert.deepStrictEqual(item.custom, custom);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-        },
-      },
-      info: {
-        topic: function () {
-          // Uses real client and stubs queue.addItem so transforms can run.
-          var rollbar = new Rollbar({
-            accessToken: 'abc123',
-            captureUncaught: false,
-          });
-          var notifier = rollbar.client.notifier;
-          rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
-
-          return rollbar;
-        },
-        'should send message when called with only null argument': function (
-          r,
-        ) {
-          var addItemStub = r.addItemStub;
-
-          r.info(null);
-          assert.isTrue(addItemStub.called);
-          if (addItemStub.called) {
-            assert.equal(
-              addItemStub.getCall(0).args[3].data.body.message.body,
-              'Item sent with null or missing arguments.',
-            );
-          }
-          addItemStub.reset();
-        },
-        'should send message when called with no arguments': function (r) {
-          var addItemStub = r.addItemStub;
-
-          r.info();
-          assert.isTrue(addItemStub.called);
-          if (addItemStub.called) {
-            assert.equal(
-              addItemStub.getCall(0).args[3].data.body.message.body,
-              'Item sent with null or missing arguments.',
-            );
-          }
-          addItemStub.reset();
-        },
-      },
-      error: {
-        'with unordered options': {
-          'should work with custom, request, callback, message ': function (r) {
-            var err = new Error('hello!');
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            var request = { method: 'GET' };
-            var custom = { a: 1, b: 2 };
-            r.log(custom, request, callback, err);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-            assert.equal(item.request, request);
-            assert.deepStrictEqual(item.custom, custom);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-        },
-        'with old option ordering': {
-          'should work': function (r) {
-            var err = new Error('hello!');
-            r.log(err);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-          },
-          'should work with callback': function (r) {
-            var err = new Error('hello!');
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            r.log(err, callback);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-          'should work with request': function (r) {
-            var err = new Error('hello!');
-            var request = { method: 'GET' };
-            r.log(err, request);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-            assert.equal(item.request, request);
-          },
-          'should work with request and callback': function (r) {
-            var err = new Error('hello!');
-            var request = { method: 'GET' };
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            r.log(err, request, callback);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-            assert.equal(item.request, request);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-          'should work with request and custom': function (r) {
-            var err = new Error('hello!');
-            var request = { method: 'GET' };
-            var custom = { a: 1, b: 2 };
-            r.log(err, request, custom);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-            assert.equal(item.request, request);
-            assert.deepStrictEqual(item.custom, custom);
-          },
-          'should work with request and custom and callback': function (r) {
-            var err = new Error('hello!');
-            var request = { method: 'GET' };
-            var custom = { a: 1, b: 2 };
-            var callbackCalled = false;
-            var callback = function cb() {
-              callbackCalled = true;
-            };
-            r.log(err, request, custom, callback);
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-            assert.equal(item.err, err);
-            assert.equal(item.request, request);
-            assert.deepStrictEqual(item.custom, custom);
-            item.callback();
-            assert.isTrue(callbackCalled);
-          },
-        },
-      },
-    },
-    // captureUncaught tests are set up using subtopics because Rollbar's node.js handlers
-    // are treated as global and concurrent access will lead to handlers being removed
-    // unexpectedly. (Subtopics execute sequentially.)
-    captureUncaught: {
-      'enabled in constructor': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            accessToken: 'abc123',
-            captureUncaught: true,
-          });
-          var notifier = rollbar.client.notifier;
-          rollbar.logStub = sinon.stub(notifier, 'log');
-
-          nodeThrow(rollbar, this.callback);
-        },
-        'should have locals disabled': function (r) {
-          assert.equal(r.client.notifier.locals, undefined);
-        },
-        'should log': function (r) {
-          var logStub = r.logStub;
-
-          assert.isTrue(logStub.called);
-          if (logStub.called) {
-            assert.equal(logStub.getCall(0).args[0].err.message, 'node error');
-          }
-          logStub.reset();
-        },
-        'disabled in configure': {
-          topic: function (r) {
-            r.configure({
-              captureUncaught: false,
-            });
-
-            nodeThrow(r, this.callback);
-          },
-          'should not log': function (r) {
-            var notifier = r.client.notifier;
-            var logStub = r.logStub;
-
-            assert.isFalse(logStub.called);
-            notifier.log.restore();
-          },
-          'disabled in constructor': {
-            topic: function () {
-              var rollbar = new Rollbar({
-                accessToken: 'abc123',
-                captureUncaught: false,
-              });
-              var notifier = rollbar.client.notifier;
-              rollbar.logStub = sinon.stub(notifier, 'log');
-
-              nodeThrow(rollbar, this.callback);
-            },
-            'should not log': function (r) {
-              var logStub = r.logStub;
-
-              assert.isFalse(logStub.called);
-              logStub.reset();
-            },
-            'enabled in configure': {
-              topic: function (r) {
-                r.configure({
-                  captureUncaught: true,
-                });
-
-                nodeThrow(r, this.callback);
-              },
-              'should log': function (r) {
-                var notifier = r.client.notifier;
-                var logStub = r.logStub;
-
-                assert.isTrue(logStub.called);
-                if (logStub.called) {
-                  assert.equal(
-                    logStub.getCall(0).args[0].err.message,
-                    'node error',
-                  );
-                }
-                notifier.log.restore();
-              },
-            },
-          },
-        },
-      },
-    },
-    // captureUnhandledRejections tests are set up using subtopics because Rollbar's node.js handlers
-    // are treated as global and concurrent access will lead to handlers being removed
-    // unexpectedly. (Subtopics execute sequentially.)
-    captureUnhandledRejections: {
-      'enabled in constructor': {
-        topic: function () {
-          var rollbar = new Rollbar({
-            accessToken: 'abc123',
-            captureUnhandledRejections: true,
-          });
-          var notifier = rollbar.client.notifier;
-          rollbar.logStub = sinon.stub(notifier, 'log');
-
-          nodeReject(rollbar, this.callback);
-        },
-        'should log': function (r) {
-          var logStub = r.logStub;
-
-          assert.isTrue(logStub.called);
-          if (logStub.called) {
-            assert.equal(logStub.getCall(0).args[0].err.message, 'node reject');
-          }
-          logStub.reset();
-        },
-        'disabled in configure': {
-          topic: function (r) {
-            r.configure({
-              captureUnhandledRejections: false,
-            });
-
-            nodeReject(r, this.callback);
-          },
-          'should not log': function (r) {
-            var notifier = r.client.notifier;
-            var logStub = r.logStub;
-
-            assert.isFalse(logStub.called);
-            notifier.log.restore();
-          },
-          'disabled in constructor': {
-            topic: function () {
-              var rollbar = new Rollbar({
-                accessToken: 'abc123',
-                captureUnhandledRejections: false,
-              });
-              var notifier = rollbar.client.notifier;
-              rollbar.logStub = sinon.stub(notifier, 'log');
-
-              nodeReject(rollbar, this.callback);
-            },
-            'should not log': function (r) {
-              var logStub = r.logStub;
-
-              assert.isFalse(logStub.called);
-              logStub.reset();
-            },
-            'enabled in configure': {
-              topic: function (r) {
-                r.configure({
-                  captureUnhandledRejections: true,
-                });
-
-                nodeReject(r, this.callback);
-              },
-              'should log': function (r) {
-                var notifier = r.client.notifier;
-                var logStub = r.logStub;
-
-                assert.isTrue(logStub.called);
-                if (logStub.called) {
-                  assert.equal(
-                    logStub.getCall(0).args[0].err.message,
-                    'node reject',
-                  );
-                }
-                notifier.log.restore();
-              },
-            },
-          },
-        },
-      },
-    },
-    buildJsonPayload: {
-      topic: function () {
-        var client = new (TestClientGen())();
-        var rollbar = new Rollbar({ accessToken: 'abc123' }, client);
-        return rollbar;
-      },
-      'should work': function (r) {
-        var obj = { foo: 'bar' };
-        r.buildJsonPayload(obj);
-        var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-        assert.equal(obj, item);
-      },
-    },
-    sendJsonPayload: {
-      topic: function () {
-        var client = new (TestClientGen())();
-        var rollbar = new Rollbar({ accessToken: 'abc123' }, client);
-        return rollbar;
-      },
-      'should work': function (r) {
-        var json = '{ "foo": "bar" }';
-        r.sendJsonPayload(json);
-        var item = r.client.logCalls[r.client.logCalls.length - 1].item;
-        assert.equal(json, item);
-      },
-    },
-    singleton: {
-      topic: function () {
-        var client = new (TestClientGen())();
-        return Rollbar.init({ accessToken: 'abc123' }, client);
-      },
-      'should allow log on constructor to pass through': function (r) {
-        r.log('hello 1');
-        Rollbar.log('hello 2');
-        assert.equal(r.client.logCalls[0].item.message, 'hello 1');
-        assert.equal(r.client.logCalls[1].item.message, 'hello 2');
-      },
-    },
-  })
-  .export(module, { error: false });