polish(sentry): Cleanup browser.ts and tests

Author: dschom

libs/shared/sentry/src/lib/browser.spec.ts

@@ -3,12 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 import 'jsdom-global/register';
 import * as Sentry from '@sentry/browser';
-import sentryMetrics, { _Sentry } from './browser';
+import * as sentryWrapper from './browser';
 import { SentryConfigOpts } from './models/SentryConfigOpts';
-import { Logger } from './sentry.types';
 
-const sinon = require('sinon');
-const sandbox = sinon.createSandbox();
+jest.mock('@sentry/browser', () => {
+  const actual = jest.requireActual('@sentry/browser');
+  return {
+    ...actual,
+    init: jest.fn(),
+    captureException: jest.fn(),
+  };
+});
 
 const config: SentryConfigOpts = {
   release: 'v0.0.0',
@@ -19,45 +24,41 @@ const config: SentryConfigOpts = {
     sampleRate: 0,
   },
 };
-const logger: Logger = {
+const logger = {
   info: jest.fn(),
   warn: jest.fn(),
   error: jest.fn(),
   debug: jest.fn(),
 };
 
 describe('sentry/browser', () => {
-  beforeAll(() => {
-    // Reduce console log noise in test output
-    sandbox.spy(console, 'error');
-  });
-
   beforeEach(() => {
     // Make sure it's enabled by default
-    sentryMetrics.enable();
+    sentryWrapper.enable();
   });
 
-  afterAll(() => {
-    sandbox.restore();
+  afterEach(() => {
+    jest.resetAllMocks();
+    jest.resetModules();
   });
 
   describe('init', () => {
     it('properly configures with dsn', () => {
-      sentryMetrics.configure(config, logger);
+      sentryWrapper.configure(config, logger);
     });
   });
 
   describe('beforeSend', () => {
     beforeAll(() => {
-      sentryMetrics.configure(config, logger);
+      sentryWrapper.configure(config, logger);
     });
 
     it('works without request url', () => {
       const data = {
         key: 'value',
       } as Sentry.Event;
 
-      const resultData = sentryMetrics.__beforeSend(config, data, {});
+      const resultData = sentryWrapper.beforeSend(config, data, {});
 
       expect(data).toEqual(resultData);
     });
@@ -72,35 +73,34 @@ describe('sentry/browser', () => {
         },
       } as Sentry.Event;
 
-      const resultData = sentryMetrics.__beforeSend(config, data, {});
+      const resultData = sentryWrapper.beforeSend(config, data, {});
       expect(resultData?.fingerprint?.[0]).toEqual('errno100');
       expect(resultData?.level).toEqual('info');
     });
   });
 
   describe('captureException', () => {
     it('calls Sentry.captureException', () => {
-      const sentryCaptureException = sinon.stub(_Sentry, 'captureException');
-      sentryMetrics.captureException(new Error('testo'));
-      sinon.assert.calledOnce(sentryCaptureException);
-      sentryCaptureException.restore();
+      const spy = jest.spyOn(Sentry, 'captureException');
+      Sentry.captureException(new Error('testo'));
+      expect(spy).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('disable / enables', () => {
     it('enables', () => {
-      sentryMetrics.enable();
-      expect(sentryMetrics.__sentryEnabled()).toBeTruthy();
+      sentryWrapper.enable();
+      expect(sentryWrapper.isEnabled()).toBeTruthy();
     });
 
     it('disables', () => {
-      sentryMetrics.disable();
-      expect(sentryMetrics.__sentryEnabled()).toBeFalsy();
+      sentryWrapper.disable();
+      expect(sentryWrapper.isEnabled()).toBeFalsy();
     });
 
     it('will return null from before send when disabled', () => {
-      sentryMetrics.disable();
-      expect(sentryMetrics.__beforeSend({}, {}, {})).toBeNull();
+      sentryWrapper.disable();
+      expect(sentryWrapper.beforeSend({}, {}, {})).toBeNull();
     });
   });
 });

libs/shared/sentry/src/lib/browser.ts

@@ -16,48 +16,7 @@ const EXCEPTION_TAGS = ['code', 'context', 'errno', 'namespace', 'status'];
 // Internal flag to keep track of whether or not sentry is initialized
 let sentryEnabled = false;
 
-// HACK: allow tests to stub this function from Sentry
-// https://stackoverflow.com/questions/35240469/how-to-mock-the-imports-of-an-es6-module
-export const _Sentry = {
-  captureException: Sentry.captureException,
-  close: Sentry.close,
-};
-
-/**
- * function that gets called before data gets sent to error metrics
- *
- * @param {Object} event
- *  Error object data
- * @returns {Object} data
- *  Modified error object data
- * @private
- */
-function beforeSend(
-  opts: SentryConfigOpts,
-  event: Sentry.ErrorEvent,
-  hint?: Sentry.EventHint
-) {
-  if (sentryEnabled === false) {
-    return null;
-  }
-
-  if (event.request) {
-    if (event.tags) {
-      // if this is a known errno, then use grouping with fingerprints
-      // Docs: https://docs.sentry.io/hosted/learn/rollups/#fallback-grouping
-      if (event.tags.errno) {
-        event.fingerprint = ['errno' + (event.tags.errno as number)];
-        // if it is a known error change the error level to info.
-        event.level = 'info';
-      }
-    }
-  }
-
-  event = tagFxaName(event, opts.sentry?.clientName || opts.sentry?.serverName);
-  return event;
-}
-
-function captureException(err: Error) {
+export function captureException(err: Error) {
   if (!sentryEnabled) {
     return;
   }
@@ -79,15 +38,59 @@ function captureException(err: Error) {
   });
 }
 
-function disable() {
+export function isEnabled() {
+  return sentryEnabled;
+}
+
+/**
+ * Toggle sentry error capture to be disabled.
+ */
+export function disable() {
   sentryEnabled = false;
 }
 
-function enable() {
+/**
+ * Toggle sentry error capture to be enabled.
+ */
+export function enable() {
   sentryEnabled = true;
 }
 
-function configure(config: SentryConfigOpts, log?: Logger) {
+/**
+ * Gets called before data gets sent to error metrics. Useful for altering event state before it gets sent to Sentry.
+ * For example, we use this to set the event fingerprint based on known error numbers.
+ *
+ * @param {Object} opts - Sentry configuration options
+ * @param {Object} event - Sentry error object data
+ * @param {Object} hint - Sentry error object hint data
+ * @returns {Object} event - Modified error object data
+ */
+export function beforeSend(
+  opts: SentryConfigOpts,
+  event: Sentry.Event,
+  _hint?: Sentry.EventHint
+) {
+  if (sentryEnabled === false) {
+    return null;
+  }
+
+  if (event.request) {
+    if (event.tags) {
+      // if this is a known errno, then use grouping with fingerprints
+      // Docs: https://docs.sentry.io/hosted/learn/rollups/#fallback-grouping
+      if (event.tags.errno) {
+        event.fingerprint = ['errno' + (event.tags.errno as number)];
+        // if it is a known error change the error level to info.
+        event.level = 'info';
+      }
+    }
+  }
+
+  event = tagFxaName(event, opts.sentry?.clientName || opts.sentry?.serverName);
+  return event;
+}
+
+export function configure(config: SentryConfigOpts, log?: Logger) {
   if (!log) {
     log = console;
   }
@@ -106,22 +109,11 @@ function configure(config: SentryConfigOpts, log?: Logger) {
   try {
     Sentry.init({
       ...opts,
-      beforeSend: function (event: Sentry.ErrorEvent, hint: Sentry.EventHint) {
+      beforeSend: function (event: Sentry.ErrorEvent, hint?: Sentry.EventHint) {
         return beforeSend(opts, event, hint);
       },
     });
   } catch (e) {
     log.error(e);
   }
 }
-
-export default {
-  configure,
-  captureException,
-  disable,
-  enable,
-  __sentryEnabled: function () {
-    return sentryEnabled;
-  },
-  __beforeSend: beforeSend,
-};