rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.rollbar.constructor.mocha.test.mjs

@@ -0,0 +1,199 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import Rollbar from '../src/server/rollbar.js';
+import {
+  ValidOpenTracingTracerStub,
+  InvalidOpenTracingTracerStub,
+} from './server.rollbar.test-utils.mjs';
+
+describe('rollbar constructor and configuration', function () {
+  describe('constructor', function () {
+    describe('with accessToken', function () {
+      it('should have log method', function () {
+        const r = new Rollbar('abc123');
+        expect(r.log).to.be.a('function');
+      });
+
+      it('should have error method', function () {
+        const r = new Rollbar('abc123');
+        expect(r.error).to.be.a('function');
+      });
+
+      it('should have buildJsonPayload method', function () {
+        const r = new Rollbar('abc123');
+        expect(r.buildJsonPayload).to.be.a('function');
+      });
+
+      it('should have sendJsonPayload method', function () {
+        const r = new Rollbar('abc123');
+        expect(r.sendJsonPayload).to.be.a('function');
+      });
+
+      it('should have accessToken in options', function () {
+        const r = new Rollbar('abc123');
+        expect(r.options.accessToken).to.equal('abc123');
+      });
+    });
+
+    describe('with options', function () {
+      it('should have log method', function () {
+        const r = new Rollbar({ accessToken: 'abc123' });
+        expect(r.log).to.be.a('function');
+      });
+
+      it('should have error method', function () {
+        const r = new Rollbar({ accessToken: 'abc123' });
+        expect(r.error).to.be.a('function');
+      });
+
+      it('should have accessToken in options', function () {
+        const r = new Rollbar({ accessToken: 'abc123' });
+        expect(r.options.accessToken).to.equal('abc123');
+      });
+
+      it('should set environment based on default', function () {
+        const r = new Rollbar({ accessToken: 'abc123' });
+        expect(r.options.environment).to.be.a('string');
+        expect(r.options.environment).to.not.be.empty;
+        expect(r.options.environment).to.equal(
+          Rollbar.defaultOptions.environment,
+        );
+      });
+    });
+
+    describe('with more options', function () {
+      it('should have log method', function () {
+        const r = new Rollbar({
+          accessToken: 'abc123',
+          environment: 'fake-env',
+        });
+        expect(r.log).to.be.a('function');
+      });
+
+      it('should have error method', function () {
+        const r = new Rollbar({
+          accessToken: 'abc123',
+          environment: 'fake-env',
+        });
+        expect(r.error).to.be.a('function');
+      });
+
+      it('should have accessToken in options', function () {
+        const r = new Rollbar({
+          accessToken: 'abc123',
+          environment: 'fake-env',
+        });
+        expect(r.options.accessToken).to.equal('abc123');
+      });
+
+      it('should set environment based on options', function () {
+        const r = new Rollbar({
+          accessToken: 'abc123',
+          environment: 'fake-env',
+        });
+        expect(r.options.environment).to.equal('fake-env');
+      });
+
+      it('should set configured options', function () {
+        const r = new Rollbar({
+          accessToken: 'abc123',
+          environment: 'fake-env',
+        });
+        expect(r.options._configuredOptions.environment).to.equal('fake-env');
+      });
+    });
+
+    describe('with deprecated options', function () {
+      it('should replace options', function () {
+        const r = new Rollbar({
+          hostWhiteList: ['foo'],
+          hostBlackList: ['bar'],
+        });
+        expect(r.options.hostWhiteList).to.be.undefined;
+        expect(r.options.hostBlackList).to.be.undefined;
+        expect(r.options.hostSafeList).to.deep.equal(['foo']);
+        expect(r.options.hostBlockList).to.deep.equal(['bar']);
+      });
+    });
+
+    describe('with valid tracer', function () {
+      it('should configure tracer', function () {
+        const r = new Rollbar({
+          captureUncaught: true,
+          environment: 'fake-env',
+          tracer: ValidOpenTracingTracerStub,
+        });
+        expect(r.client.tracer).to.be.an('object');
+      });
+    });
+
+    describe('with invalid tracer', function () {
+      it('should configure tracer', function () {
+        const r = new Rollbar({
+          captureUncaught: true,
+          environment: 'fake-env',
+          tracer: InvalidOpenTracingTracerStub,
+        });
+        expect(r.client.tracer).to.be.null;
+      });
+    });
+  });
+
+  describe('configure', function () {
+    describe('with updated options', function () {
+      it('should set configured options', function () {
+        const rollbar = new Rollbar({
+          captureUncaught: true,
+          environment: 'fake-env',
+        });
+        rollbar.configure({ captureUncaught: false, environment: 'new-env' });
+
+        expect(rollbar.options._configuredOptions.environment).to.equal(
+          'new-env',
+        );
+        expect(rollbar.options._configuredOptions.captureUncaught).to.be.false;
+      });
+    });
+
+    describe('with deprecated options', function () {
+      it('should replace options', function () {
+        const rollbar = new Rollbar({ captureUncaught: true });
+        rollbar.configure({
+          hostWhiteList: ['foo'],
+          hostBlackList: ['bar'],
+        });
+
+        expect(rollbar.options.hostWhiteList).to.be.undefined;
+        expect(rollbar.options.hostBlackList).to.be.undefined;
+        expect(rollbar.options.hostSafeList).to.deep.equal(['foo']);
+        expect(rollbar.options.hostBlockList).to.deep.equal(['bar']);
+      });
+    });
+
+    describe('with valid tracer', function () {
+      it('should configure tracer', function () {
+        const rollbar = new Rollbar({
+          captureUncaught: true,
+          environment: 'fake-env',
+        });
+        rollbar.configure({ tracer: ValidOpenTracingTracerStub });
+
+        expect(rollbar.client.tracer).to.equal(ValidOpenTracingTracerStub);
+      });
+    });
+
+    describe('with invalid tracer', function () {
+      it('should configure tracer', function () {
+        const rollbar = new Rollbar({
+          captureUncaught: true,
+          environment: 'fake-env',
+        });
+        rollbar.configure({ tracer: InvalidOpenTracingTracerStub });
+
+        expect(rollbar.client.tracer).to.be.null;
+      });
+    });
+  });
+});

package/test/server.rollbar.handlers.mocha.test.mjs

@@ -0,0 +1,253 @@
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import Rollbar from '../src/server/rollbar.js';
+
+async function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+async function nodeReject() {
+  Promise.reject(new Error('node reject'));
+  await wait(500);
+}
+
+async function nodeThrow() {
+  setTimeout(function () {
+    throw new Error('node error');
+  }, 10);
+  await wait(500);
+}
+
+describe('rollbar exception handlers', function () {
+  before(function () {
+    // Increase max listeners to avoid warnings during tests
+    // Multiple Rollbar instances are created and each adds handlers
+    process.setMaxListeners(20);
+  });
+
+  after(function () {
+    process.setMaxListeners(10);
+  });
+
+  describe('captureUncaught', function () {
+    let mochaHandlers;
+
+    beforeEach(function () {
+      // Remove Mocha's uncaught exception handlers to prevent interference
+      mochaHandlers = process.listeners('uncaughtException');
+      mochaHandlers.forEach((handler) => {
+        process.removeListener('uncaughtException', handler);
+      });
+    });
+
+    afterEach(function () {
+      // Restore Mocha's handlers
+      mochaHandlers.forEach((handler) => {
+        process.on('uncaughtException', handler);
+      });
+    });
+
+    describe('enabled in constructor', function () {
+      let rollbar;
+      let logStub;
+
+      beforeEach(async function () {
+        rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUncaught: true,
+        });
+        logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        await nodeThrow();
+      });
+
+      afterEach(function () {
+        logStub.restore();
+      });
+
+      it('should have locals disabled', function () {
+        expect(rollbar.client.notifier.locals).to.be.undefined;
+      });
+
+      it('should log', function () {
+        expect(logStub.called).to.be.true;
+        expect(logStub.getCall(0).args[0].err.message).to.equal('node error');
+      });
+    });
+
+    describe('disabled in configure after being enabled', function () {
+      it('should not log when disabled', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUncaught: true,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        await nodeThrow();
+        expect(logStub.called).to.be.true;
+        logStub.reset();
+
+        rollbar.configure({ captureUncaught: false });
+        await nodeThrow();
+        expect(logStub.called).to.be.false;
+
+        logStub.restore();
+      });
+    });
+
+    describe('disabled in constructor', function () {
+      it('should not log', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUncaught: false,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        // Install a temporary handler to prevent test crash
+        const tempHandler = () => {};
+        process.on('uncaughtException', tempHandler);
+
+        await nodeThrow();
+        expect(logStub.called).to.be.false;
+
+        process.removeListener('uncaughtException', tempHandler);
+        logStub.restore();
+      });
+    });
+
+    describe('enabled in configure after being disabled', function () {
+      it('should log when enabled', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUncaught: false,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        // Install a temporary handler to prevent test crash when disabled
+        const tempHandler = () => {};
+        process.on('uncaughtException', tempHandler);
+
+        await nodeThrow();
+        expect(logStub.called).to.be.false;
+
+        process.removeListener('uncaughtException', tempHandler);
+
+        rollbar.configure({ captureUncaught: true });
+        await nodeThrow();
+        expect(logStub.called).to.be.true;
+        expect(logStub.getCall(0).args[0].err.message).to.equal('node error');
+
+        logStub.restore();
+      });
+    });
+  });
+
+  describe('captureUnhandledRejections', function () {
+    let mochaHandlers;
+
+    beforeEach(function () {
+      // Remove Mocha's unhandled rejection handlers to prevent interference
+      mochaHandlers = process.listeners('unhandledRejection');
+      mochaHandlers.forEach((handler) => {
+        process.removeListener('unhandledRejection', handler);
+      });
+    });
+
+    afterEach(function () {
+      // Restore Mocha's handlers
+      mochaHandlers.forEach((handler) => {
+        process.on('unhandledRejection', handler);
+      });
+    });
+
+    describe('enabled in constructor', function () {
+      it('should log', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUnhandledRejections: true,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        await nodeReject();
+
+        expect(logStub.called).to.be.true;
+        expect(logStub.getCall(0).args[0].err.message).to.equal('node reject');
+
+        logStub.restore();
+      });
+    });
+
+    describe('disabled in configure after being enabled', function () {
+      it('should not log when disabled', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUnhandledRejections: true,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        await nodeReject();
+        expect(logStub.called).to.be.true;
+        logStub.reset();
+
+        rollbar.configure({ captureUnhandledRejections: false });
+        await nodeReject();
+        expect(logStub.called).to.be.false;
+
+        logStub.restore();
+      });
+    });
+
+    describe('disabled in constructor', function () {
+      it('should not log', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUnhandledRejections: false,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        // Install a temporary handler to prevent test crash
+        const tempHandler = () => {};
+        process.on('unhandledRejection', tempHandler);
+
+        await nodeReject();
+        expect(logStub.called).to.be.false;
+
+        process.removeListener('unhandledRejection', tempHandler);
+        logStub.restore();
+      });
+    });
+
+    describe('enabled in configure after being disabled', function () {
+      it('should log when enabled', async function () {
+        const rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUnhandledRejections: false,
+        });
+        const logStub = sinon.stub(rollbar.client.notifier, 'log');
+
+        // Install a temporary handler to prevent test crash when disabled
+        const tempHandler = () => {};
+        process.on('unhandledRejection', tempHandler);
+
+        await nodeReject();
+        expect(logStub.called).to.be.false;
+
+        process.removeListener('unhandledRejection', tempHandler);
+
+        rollbar.configure({ captureUnhandledRejections: true });
+        await nodeReject();
+        expect(logStub.called).to.be.true;
+        expect(logStub.getCall(0).args[0].err.message).to.equal('node reject');
+
+        logStub.restore();
+      });
+    });
+  });
+});