silence extraneous output in tests

Author: lobsterkatie

packages/integrations/test/captureconsole.test.ts

@@ -16,6 +16,15 @@ const mockHub = {
   captureException: jest.fn(),
 };
 
+const mockConsole = {
+  debug: jest.fn(),
+  log: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  assert: jest.fn(),
+  info: jest.fn(),
+};
+
 const getMockHubWithIntegration = (integration: Integration) => ({
   ...mockHub,
   getIntegration: jest.fn(() => integration),
@@ -25,63 +34,81 @@ const getMockHubWithIntegration = (integration: Integration) => ({
 const originalConsole = Object.assign({}, global.console);
 
 describe('CaptureConsole setup', () => {
+  beforeEach(() => {
+    // this suppresses output to the terminal running the tests, but doesn't interfere with our wrapping
+    Object.assign(global.console, mockConsole);
+  });
+
   afterEach(() => {
     jest.clearAllMocks();
 
     // Un-monkey-patch the console functions
     Object.assign(global.console, originalConsole);
   });
 
-  it('should patch user-configured console levels', () => {
-    const captureConsoleIntegration = new CaptureConsole({ levels: ['log', 'warn'] });
-    captureConsoleIntegration.setupOnce(
-      () => undefined,
-      () => getMockHubWithIntegration(captureConsoleIntegration) as any,
-    );
+  describe('monkeypatching', () => {
+    beforeEach(() => {
+      // for these tests only, we don't want to use the mock console, because we're testing for equality to methods from
+      // the original, so undo the global `beforeEach()`
+      Object.assign(global.console, originalConsole);
+    });
 
-    expect(global.console.error).toBe(originalConsole.error); // not monkey patched
-    expect(global.console.log).not.toBe(originalConsole.log); // monkey patched
-    expect(global.console.warn).not.toBe(originalConsole.warn); // monkey patched
-  });
+    it('should patch user-configured console levels', () => {
+      global.console.error = originalConsole.error;
 
-  it('should fall back to default console levels if none are provided', () => {
-    const captureConsoleIntegration = new CaptureConsole();
-    captureConsoleIntegration.setupOnce(
-      () => undefined,
-      () => getMockHubWithIntegration(captureConsoleIntegration) as any,
-    );
+      const captureConsoleIntegration = new CaptureConsole({ levels: ['log', 'warn'] });
+      captureConsoleIntegration.setupOnce(
+        () => undefined,
+        () => getMockHubWithIntegration(captureConsoleIntegration) as any,
+      );
 
-    // expect a set of defined console levels to have been monkey patched
-    expect(global.console.debug).not.toBe(originalConsole.debug);
-    expect(global.console.info).not.toBe(originalConsole.info);
-    expect(global.console.warn).not.toBe(originalConsole.warn);
-    expect(global.console.error).not.toBe(originalConsole.error);
-    expect(global.console.log).not.toBe(originalConsole.log);
-    expect(global.console.assert).not.toBe(originalConsole.assert);
+      expect(global.console.error).toBe(originalConsole.error); // not monkey patched
+      expect(global.console.log).not.toBe(originalConsole.log); // monkey patched
+      expect(global.console.warn).not.toBe(originalConsole.warn); // monkey patched
+    });
 
-    // any other fields should not have been patched
-    expect(global.console.trace).toBe(originalConsole.trace);
-    expect(global.console.table).toBe(originalConsole.table);
-  });
+    it('should fall back to default console levels if none are provided', () => {
+      const captureConsoleIntegration = new CaptureConsole();
+      captureConsoleIntegration.setupOnce(
+        () => undefined,
+        () => getMockHubWithIntegration(captureConsoleIntegration) as any,
+      );
 
-  it('should not wrap any functions with an empty levels option', () => {
-    const captureConsoleIntegration = new CaptureConsole({ levels: [] });
-    captureConsoleIntegration.setupOnce(
-      () => undefined,
-      () => getMockHubWithIntegration(captureConsoleIntegration) as any,
-    );
+      // expect a set of defined console levels to have been monkey patched
+      expect(global.console.debug).not.toBe(originalConsole.debug);
+      expect(global.console.info).not.toBe(originalConsole.info);
+      expect(global.console.warn).not.toBe(originalConsole.warn);
+      expect(global.console.error).not.toBe(originalConsole.error);
+      expect(global.console.log).not.toBe(originalConsole.log);
+      expect(global.console.assert).not.toBe(originalConsole.assert);
+
+      // any other fields should not have been patched
+      expect(global.console.trace).toBe(originalConsole.trace);
+      expect(global.console.table).toBe(originalConsole.table);
+    });
+
+    it('should not wrap any functions with an empty levels option', () => {
+      const captureConsoleIntegration = new CaptureConsole({ levels: [] });
+      captureConsoleIntegration.setupOnce(
+        () => undefined,
+        () => getMockHubWithIntegration(captureConsoleIntegration) as any,
+      );
 
-    // expect the default set of console levels not to have been monkey patched
-    expect(global.console.debug).toBe(originalConsole.debug);
-    expect(global.console.info).toBe(originalConsole.info);
-    expect(global.console.warn).toBe(originalConsole.warn);
-    expect(global.console.error).toBe(originalConsole.error);
-    expect(global.console.log).toBe(originalConsole.log);
-    expect(global.console.assert).toBe(originalConsole.assert);
+      // expect the default set of console levels not to have been monkey patched
+      expect(global.console.debug).toBe(originalConsole.debug);
+      expect(global.console.info).toBe(originalConsole.info);
+      expect(global.console.warn).toBe(originalConsole.warn);
+      expect(global.console.error).toBe(originalConsole.error);
+      expect(global.console.log).toBe(originalConsole.log);
+      expect(global.console.assert).toBe(originalConsole.assert);
 
-    // expect no message to be captured with console.log
-    global.console.log('some message');
-    expect(mockHub.captureMessage).not.toHaveBeenCalled();
+      // suppress output from the logging we're about to do
+      global.console.log = global.console.info = jest.fn();
+
+      // expect no message to be captured with console.log
+      global.console.log('some message');
+      expect(mockHub.captureMessage).not.toHaveBeenCalled();
+    });
   });
 
   it('setup should fail gracefully when console is not available', () => {

packages/node-integration-tests/suites/tracing/auto-instrument/mongodb/scenario.ts

@@ -3,6 +3,9 @@ import '@sentry/tracing';
 import * as Sentry from '@sentry/node';
 import { MongoClient } from 'mongodb';
 
+// suppress logging of the mongo download
+global.console.log = () => null;
+
 Sentry.init({
   dsn: 'https://[email protected]/1337',
   release: '1.0',

packages/node/package.json

@@ -60,7 +60,7 @@
     "test:express": "node test/manual/express-scope-separation/start.js",
     "test:jest": "jest",
     "test:release-health": "node test/manual/release-health/runner.js",
-    "test:webpack": "cd test/manual/webpack-domain/ && yarn && node npm-build.js",
+    "test:webpack": "cd test/manual/webpack-domain/ && yarn --silent && node npm-build.js",
     "test:watch": "jest --watch"
   },
   "volta": {

packages/node/test/domain.test.ts

@@ -4,8 +4,9 @@ import * as domain from 'domain';
 // We need this import here to patch domain on the global object
 import * as Sentry from '../src';
 
-// eslint-disable-next-line no-console
-console.log(Sentry.SDK_NAME);
+// TODO This is here because if we don't use the `Sentry` object, the 'concurrent domain hubs' test will fail. Is this a
+// product of treeshaking?
+Sentry.getCurrentHub();
 
 describe('domains', () => {
   test('without domain', () => {

packages/node/test/manual/express-scope-separation/start.js

@@ -3,6 +3,9 @@ const express = require('express');
 const app = express();
 const Sentry = require('../../../build/cjs');
 
+// don't log the test errors we're going to throw, so at a quick glance it doesn't look like the test itself has failed
+global.console.error = () => null;
+
 function assertTags(actual, expected) {
   if (JSON.stringify(actual) !== JSON.stringify(expected)) {
     console.error('FAILED: Scope contains incorrect tags');