rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.locals.merge.mocha.test.mjs

@@ -0,0 +1,267 @@
+/* globals describe */
+/* globals it */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import Locals from '../src/server/locals.js';
+import logger from '../src/server/logger.js';
+import localsFixtures from './fixtures/locals.fixtures.js';
+
+describe('server.locals merge', function () {
+  afterEach(function () {
+    sinon.restore();
+    Locals.session = undefined;
+    Locals.currentErrors = new Map();
+  });
+
+  describe('mergeLocals', function () {
+    // Deep clone, because stack gets modified by mergeLocals
+    // and we don't want to modify the test fixtures.
+    const cloneStack = (stack) => JSON.parse(JSON.stringify(stack));
+
+    function fakeSessionPostHandler(responses) {
+      return (command, options, callback) => {
+        let error;
+        let response;
+
+        if (command === 'Runtime.getProperties') {
+          response = { result: responses[options.objectId] };
+        } else {
+          error = new Error('Unexpected session.post command');
+        }
+
+        setTimeout(() => {
+          callback(error, response);
+        }, 1);
+      };
+    }
+
+    it('should callback with error when session.post() returns error', function (done) {
+      const locals = new Locals({}, logger);
+      const err = new Error('post error');
+      sinon.stub(Locals.session, 'post').yields(err);
+
+      const key = 'key';
+      const localsMap = new Map();
+      localsMap.set('key', localsFixtures.maps.simple);
+
+      const stack = localsFixtures.stacks.simple;
+
+      locals.mergeLocals(localsMap, stack, key, (err) => {
+        expect(err).to.be.instanceOf(Error);
+        expect(err.message).to.equal('post error');
+        expect(err.stack).to.include('Error: post error');
+        done();
+      });
+    });
+
+    it('should callback with merged locals when multiple/complex locals maps present', function (done) {
+      const getPropertiesResponses = {
+        objectId1: [
+          localsFixtures.locals.object1,
+          localsFixtures.locals.object2,
+        ],
+        objectId2: [
+          localsFixtures.locals.boolean1,
+          localsFixtures.locals.boolean2,
+        ],
+        objectId3: [
+          localsFixtures.locals.string1,
+          localsFixtures.locals.array1,
+        ],
+      };
+
+      const locals = new Locals({ depth: 0 }, logger);
+      sinon
+        .stub(Locals.session, 'post')
+        .callsFake(fakeSessionPostHandler(getPropertiesResponses));
+
+      const key1 = 'key1';
+      const key2 = 'key2';
+      const localsMap = new Map();
+
+      // Test with multiple maps present.
+      localsMap.set(key1, localsFixtures.maps.simple);
+      localsMap.set(key2, localsFixtures.maps.complex); // Stack will match the 2nd locals map added.
+
+      const stack = cloneStack(localsFixtures.stacks.complex);
+
+      locals.mergeLocals(localsMap, stack, key2, (err) => {
+        expect(err).to.not.exist;
+
+        expect(stack[0].locals.response).to.equal('success');
+        expect(stack[0].locals.args).to.equal('<Array object>');
+        expect(stack[1].locals.old).to.be.false;
+        expect(stack[1].locals.new).to.be.true;
+        expect(stack[2].locals.foo).to.equal('<FooClass object>');
+        expect(stack[2].locals.bar).to.equal('<BarClass object>');
+
+        done();
+      });
+    });
+
+    it('should callback with merged locals when simple locals maps present', function (done) {
+      const getPropertiesResponses = {
+        objectId1: [
+          localsFixtures.locals.object1,
+          localsFixtures.locals.object2,
+        ],
+      };
+
+      const locals = new Locals({ depth: 0 }, logger);
+      sinon
+        .stub(Locals.session, 'post')
+        .callsFake(fakeSessionPostHandler(getPropertiesResponses));
+
+      const key = 'key';
+      const localsMap = new Map();
+      localsMap.set(key, localsFixtures.maps.simple);
+
+      const stack = cloneStack(localsFixtures.stacks.simple);
+
+      locals.mergeLocals(localsMap, stack, key, (err) => {
+        expect(err).to.not.exist;
+        expect(stack[0].locals.foo).to.equal('<FooClass object>');
+        expect(stack[0].locals.bar).to.equal('<BarClass object>');
+
+        done();
+      });
+    });
+
+    it('should callback with merged locals when depth = 1', function (done) {
+      const getPropertiesResponses = {
+        objectId1: [
+          localsFixtures.locals.object1,
+          localsFixtures.locals.object2,
+        ],
+        nestedProps1: [
+          localsFixtures.locals.string1,
+          localsFixtures.locals.boolean1,
+          localsFixtures.locals.function1,
+        ],
+        nestedProps2: [
+          localsFixtures.locals.array1,
+          localsFixtures.locals.null1,
+          localsFixtures.locals.function2,
+        ],
+      };
+
+      const locals = new Locals({ depth: 1 }, logger);
+      sinon
+        .stub(Locals.session, 'post')
+        .callsFake(fakeSessionPostHandler(getPropertiesResponses));
+
+      const key = 'key';
+      const localsMap = new Map();
+      localsMap.set(key, localsFixtures.maps.simple);
+
+      const stack = cloneStack(localsFixtures.stacks.simple);
+
+      locals.mergeLocals(localsMap, stack, key, (err) => {
+        expect(err).to.not.exist;
+
+        expect(stack[0].locals.foo).to.deep.equal({
+          response: 'success',
+          old: false,
+          func: '<Function object>',
+        });
+        expect(stack[0].locals.bar).to.deep.equal({
+          args: '<Array object>',
+          parent: null,
+          asyncFunc: '<AsyncFunction object>',
+        });
+
+        done();
+      });
+    });
+
+    it('should succeed without merged locals when no locals maps present', function (done) {
+      const getPropertiesResponses = {
+        objectId1: [
+          localsFixtures.locals.object1,
+          localsFixtures.locals.object2,
+        ],
+        objectId2: [
+          localsFixtures.locals.boolean1,
+          localsFixtures.locals.boolean2,
+        ],
+        objectId3: [
+          localsFixtures.locals.string1,
+          localsFixtures.locals.array1,
+        ],
+      };
+
+      const locals = new Locals({}, logger);
+      sinon
+        .stub(Locals.session, 'post')
+        .callsFake(fakeSessionPostHandler(getPropertiesResponses));
+
+      // Test with no maps present. 'key' won't match anything.
+      const key = 'key';
+      const localsMap = new Map();
+
+      const stack = cloneStack(localsFixtures.stacks.complex);
+
+      locals.mergeLocals(localsMap, stack, key, (err) => {
+        expect(err).to.not.exist;
+
+        expect(stack[0].locals).to.not.exist;
+        expect(stack[1].locals).to.not.exist;
+        expect(stack[2].locals).to.not.exist;
+
+        done();
+      });
+    });
+
+    it('should succeed without merged locals when no local scopes in map', function (done) {
+      const getPropertiesResponses = {
+        objectId1: [
+          localsFixtures.locals.object1,
+          localsFixtures.locals.object2,
+        ],
+        objectId2: [
+          localsFixtures.locals.boolean1,
+          localsFixtures.locals.boolean2,
+        ],
+        objectId3: [
+          localsFixtures.locals.string1,
+          localsFixtures.locals.array1,
+        ],
+      };
+
+      const locals = new Locals({}, logger);
+      sinon
+        .stub(Locals.session, 'post')
+        .callsFake(fakeSessionPostHandler(getPropertiesResponses));
+
+      const localsMap = new Map();
+      localsMap.set('key', localsFixtures.maps.noLocalScope);
+
+      const stack = cloneStack(localsFixtures.stacks.complex);
+
+      locals.mergeLocals(localsMap, stack, 'key', (err) => {
+        expect(err).to.not.exist;
+
+        expect(stack[0].locals).to.not.exist;
+        expect(stack[1].locals).to.not.exist;
+        expect(stack[2].locals).to.not.exist;
+
+        done();
+      });
+    });
+  });
+
+  describe('currentLocalsMap', function () {
+    it('should return empty map when no local scopes in map', function () {
+      const locals = new Locals({}, logger);
+
+      // Ensure empty map, as singleton might have state from other tests
+      Locals.currentErrors = new Map();
+
+      const localsMap = locals.currentLocalsMap();
+      expect(localsMap).to.be.instanceOf(Map);
+      expect(localsMap).to.be.empty;
+    });
+  });
+});

package/test/server.locals.test-utils.mjs

@@ -0,0 +1,114 @@
+/**
+ * Common test utilities for server locals tests
+ */
+
+export const nodeMajorVersion = parseInt(process.versions.node.split('.')[0]);
+
+export async function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export async function promiseReject() {
+  const error = new Error('promise reject');
+  Promise.reject(error);
+  await wait(500);
+}
+
+export async function nodeThrow() {
+  setTimeout(() => {
+    const error = new Error('node error');
+    throw error;
+  }, 1);
+
+  await wait(500);
+}
+
+export async function nodeThrowAndCatch(rollbar) {
+  setTimeout(() => {
+    const error = new Error('caught error');
+    try {
+      throw error;
+    } catch (e) {
+      rollbar.error(e);
+    }
+  }, 1);
+
+  await wait(500);
+}
+
+export async function nodeThrowNested() {
+  function nestedError(nestedMessage, _password) {
+    const nestedError = new Error(nestedMessage);
+    throw nestedError;
+  }
+
+  setTimeout(() => {
+    const message = 'test err';
+    const newMessage = `nested ${message}`;
+    const password = '123456';
+    const err = new Error(message);
+
+    try {
+      nestedError(newMessage, password);
+    } catch (e) {
+      err.nested = e;
+    }
+
+    throw err;
+  }, 1);
+
+  await wait(500);
+}
+
+export async function nodeThrowWithNestedLocals() {
+  setTimeout(() => {
+    const arr = [{ zero: [0, 0] }, { one: 1 }, { two: 2 }, { three: 3 }];
+    const obj = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f' };
+    const password = 'password';
+    const sym = Symbol('foo');
+    const error = new Error('node error');
+    throw error;
+  }, 1);
+
+  await wait(500);
+}
+
+export async function nodeThrowRecursionError() {
+  function recurse(curr, limit) {
+    if (curr < limit) {
+      recurse(curr + 1, limit);
+    } else {
+      throw new Error('deep stack error, limit=' + limit);
+    }
+  }
+
+  setTimeout(() => recurse(0, 3), 1);
+  await wait(500);
+}
+
+export function verifyRejectedPromise(addItemStub) {
+  const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+  const frames = traceChain[0].frames;
+
+  return {
+    message: traceChain[0].exception.message,
+    hasLocals: nodeMajorVersion >= 10,
+    locals:
+      nodeMajorVersion >= 18
+        ? {
+            topFrame: frames.at(-1).locals,
+            secondFrame: frames.at(-2).locals,
+          }
+        : nodeMajorVersion >= 10
+          ? {
+              topFrame: frames.at(-1).locals,
+              secondFrame: frames.at(-2).locals,
+            }
+          : {
+              topFrame: undefined,
+              secondFrame: undefined,
+            },
+  };
+}

package/test/server.parser.mocha.test.mjs

@@ -0,0 +1,87 @@
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+
+import { expect } from 'chai';
+import * as p from '../src/server/parser.js';
+
+describe('parser', function () {
+  describe('parseStack', function () {
+    describe('a valid stack trace', function () {
+      let frames;
+      let parseError;
+
+      beforeEach(function (done) {
+        const item = { diagnostic: {} };
+        const stack =
+          'ReferenceError: foo is not defined\n' +
+          '  at MethodClass.method.<anonymous> (app/server.js:2:4)\n' +
+          '  at /app/node_modules/client.js:321:23\n' +
+          '  at (/app/node_modules/client.js:321:23)\n' +
+          '  at MethodClass.method.(anonymous) (app/server.js:62:14)\n' +
+          '  at MethodClass.method (app/server.ts:52:4)\n' +
+          '  at MethodClass.method (app/server.js:62:14)\n';
+
+        p.parseStack(stack, {}, item, function (err, parsedFrames) {
+          parseError = err;
+          frames = parsedFrames;
+          done();
+        });
+      });
+
+      it('should parse valid js frame', function () {
+        const frame = frames[0];
+        expect(parseError).to.be.null;
+        expect(frame.method).to.equal('MethodClass.method');
+        expect(frame.filename).to.equal('app/server.js');
+        expect(frame.lineno).to.equal(62);
+        expect(frame.colno).to.equal(14 - 1);
+      });
+
+      it('should parse valid ts frame', function () {
+        const frame = frames[1];
+        expect(parseError).to.be.null;
+        expect(frame.method).to.equal('MethodClass.method');
+        expect(frame.filename).to.equal('app/server.ts');
+        expect(frame.lineno).to.equal(52);
+        expect(frame.colno).to.equal(4 - 1);
+      });
+
+      it('should parse method with parens', function () {
+        const frame = frames[2];
+        expect(parseError).to.be.null;
+        expect(frame.method).to.equal('MethodClass.method.(anonymous)');
+        expect(frame.filename).to.equal('app/server.js');
+        expect(frame.lineno).to.equal(62);
+        expect(frame.colno).to.equal(14 - 1);
+      });
+
+      it('should parse without method and with leading slash', function () {
+        const frame = frames[3];
+        expect(parseError).to.be.null;
+        expect(frame.method).to.equal('<unknown>');
+        expect(frame.filename).to.equal('/app/node_modules/client.js');
+        expect(frame.lineno).to.equal(321);
+        expect(frame.colno).to.equal(23 - 1);
+      });
+
+      it('should parse without method or parens', function () {
+        const frame = frames[4];
+        expect(parseError).to.be.null;
+        expect(frame.method).to.equal('<unknown>');
+        expect(frame.filename).to.equal('/app/node_modules/client.js');
+        expect(frame.lineno).to.equal(321);
+        expect(frame.colno).to.equal(23 - 1);
+      });
+
+      it('should parse method with angle brackets', function () {
+        const frame = frames[5];
+        expect(parseError).to.be.null;
+        expect(frame.method).to.equal('MethodClass.method.<anonymous>');
+        expect(frame.filename).to.equal('app/server.js');
+        expect(frame.lineno).to.equal(2);
+        expect(frame.colno).to.equal(4 - 1);
+      });
+    });
+  });
+});

package/test/server.predicates.mocha.test.mjs

@@ -0,0 +1,63 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import * as p from '../src/predicates.js';
+
+describe('predicates', function () {
+  describe('checkLevel', function () {
+    describe('an item without a level', function () {
+      const item = { body: 'nothing' };
+
+      it('should not send with a critical reportLevel', function () {
+        const settings = { reportLevel: 'critical' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.false;
+      });
+    });
+
+    describe('an item with an unknown level', function () {
+      const item = { level: 'wooo' };
+
+      it('should not send with an error reportLevel', function () {
+        const settings = { reportLevel: 'error' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.false;
+      });
+
+      it('should send with an unknown reportLevel', function () {
+        const settings = { reportLevel: 'yesss' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.true;
+      });
+
+      it('should send with settings without a reportLevel', function () {
+        const settings = { nothing: 'to see here' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.true;
+      });
+    });
+
+    describe('an item with a warning level', function () {
+      const item = { level: 'warning' };
+
+      it('should not send with an error reportLevel', function () {
+        const settings = { reportLevel: 'error' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.false;
+      });
+
+      it('should send with an info reportLevel', function () {
+        const settings = { reportLevel: 'info' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.true;
+      });
+
+      it('should send with a warning reportLevel', function () {
+        const settings = { reportLevel: 'warning' };
+        const result = p.checkLevel(item, settings);
+        expect(result).to.be.true;
+      });
+    });
+  });
+});