rollbar 2.26.3 → 3.0.0-alpha.1

package/test/server.rollbar.test.js

@@ -1,676 +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});