Revert [0.76] Fix errors with component stacks reported as warnings

- "Fix errors with component stacks reported as warnings (#46637)": 2da46a8
- "Refactor LogBox tests to spies (#46638)": 8926364
- "Add integration tests for console errors + ExceptionManager (#46636)": 094f036
- "Re-enable integration tests (#46639)": bf40710

Author: blakef

packages/react-native/Libraries/LogBox/Data/LogBoxData.js

@@ -82,9 +82,9 @@ let warningFilter: WarningFilter = function (format) {
   return {
     finalFormat: format,
     forceDialogImmediately: false,
-    suppressDialog_LEGACY: false,
+    suppressDialog_LEGACY: true,
     suppressCompletely: false,
-    monitorEvent: 'warning_unhandled',
+    monitorEvent: 'unknown',
     monitorListVersion: 0,
     monitorSampleRate: 1,
   };

packages/react-native/Libraries/LogBox/__tests__/LogBox-integration-test.js

@@ -11,44 +11,56 @@
 import {
   DoesNotUseKey,
   FragmentWithProp,
-  ManualConsoleError,
-  ManualConsoleErrorWithStack,
 } from './__fixtures__/ReactWarningFixtures';
 import * as React from 'react';
 
 const LogBoxData = require('../Data/LogBoxData');
 const TestRenderer = require('react-test-renderer');
 
-const ExceptionsManager = require('../../Core/ExceptionsManager.js');
-
 const installLogBox = () => {
-  const LogBox = require('../LogBox').default;
+  const LogBox = require('../LogBox');
+
   LogBox.install();
 };
 
 const uninstallLogBox = () => {
-  const LogBox = require('../LogBox').default;
+  const LogBox = require('../LogBox');
   LogBox.uninstall();
 };
 
-// TODO: we can remove all the symetric matchers once OSS lands component stack frames.
-// For now, the component stack parsing differs in ways we can't easily detect in this test.
-describe('LogBox', () => {
+const BEFORE_SLASH_RE = /(?:\/[a-zA-Z]+\/)(.+?)(?:\/.+)\//;
+
+const cleanPath = message => {
+  return message.replace(BEFORE_SLASH_RE, '/path/to/');
+};
+
+const cleanLog = logs => {
+  return logs.map(log => {
+    return {
+      ...log,
+      componentStack: log.componentStack.map(stack => ({
+        ...stack,
+        fileName: cleanPath(stack.fileName),
+      })),
+    };
+  });
+};
+
+// TODO(T71117418): Re-enable skipped LogBox integration tests once React component
+// stack frames are the same internally and in open source.
+// eslint-disable-next-line jest/no-disabled-tests
+describe.skip('LogBox', () => {
   const {error, warn} = console;
   const mockError = jest.fn();
   const mockWarn = jest.fn();
 
   beforeEach(() => {
     jest.resetModules();
     jest.restoreAllMocks();
-    jest.spyOn(console, 'error').mockImplementation(() => {});
 
     mockError.mockClear();
     mockWarn.mockClear();
-    // Reset ExceptionManager patching.
-    if (console._errorOriginal) {
-      console._errorOriginal = null;
-    }
+
     (console: any).error = mockError;
     (console: any).warn = mockWarn;
   });
@@ -67,10 +79,7 @@ describe('LogBox', () => {
     // so we can assert on what React logs.
     jest.spyOn(console, 'error');
 
-    let output;
-    TestRenderer.act(() => {
-      output = TestRenderer.create(<DoesNotUseKey />);
-    });
+    const output = TestRenderer.create(<DoesNotUseKey />);
 
     // The key error should always be the highest severity.
     // In LogBox, we expect these errors to:
@@ -79,37 +88,16 @@ describe('LogBox', () => {
     //   - Pass to console.error, with a "Warning" prefix so it does not pop a RedBox.
     expect(output).toBeDefined();
     expect(mockWarn).not.toBeCalled();
-    expect(console.error).toBeCalledTimes(1);
-    expect(console.error.mock.calls[0]).toEqual([
-      'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.%s',
-      '\n\nCheck the render method of `DoesNotUseKey`.',
-      '',
-      expect.stringMatching('at DoesNotUseKey'),
-    ]);
-    expect(spy).toHaveBeenCalledWith({
-      level: 'error',
-      category: expect.stringContaining(
-        'Warning: Each child in a list should have a unique',
-      ),
-      componentStack: expect.anything(),
-      componentStackType: 'stack',
-      message: {
-        content:
-          'Warning: Each child in a list should have a unique "key" prop.\n\nCheck the render method of `DoesNotUseKey`. See https://react.dev/link/warning-keys for more information.',
-        substitutions: [
-          {length: 45, offset: 62},
-          {length: 0, offset: 107},
-        ],
-      },
-    });
+    expect(console.error.mock.calls[0].map(cleanPath)).toMatchSnapshot(
+      'Log sent from React',
+    );
+    expect(cleanLog(spy.mock.calls[0])).toMatchSnapshot('Log added to LogBox');
+    expect(mockError.mock.calls[0].map(cleanPath)).toMatchSnapshot(
+      'Log passed to console error',
+    );
 
     // The Warning: prefix is added due to a hack in LogBox to prevent double logging.
-    // We also interpolate the string before passing to the underlying console method.
-    expect(mockError.mock.calls[0]).toEqual([
-      expect.stringMatching(
-        'Warning: Each child in a list should have a unique "key" prop.\n\nCheck the render method of `DoesNotUseKey`. See https://react.dev/link/warning-keys for more information.\n    at ',
-      ),
-    ]);
+    expect(mockError.mock.calls[0][0].startsWith('Warning: ')).toBe(true);
   });
 
   it('integrates with React and handles a fragment warning in LogBox', () => {
@@ -120,10 +108,7 @@ describe('LogBox', () => {
     // so we can assert on what React logs.
     jest.spyOn(console, 'error');
 
-    let output;
-    TestRenderer.act(() => {
-      output = TestRenderer.create(<FragmentWithProp />);
-    });
+    const output = TestRenderer.create(<FragmentWithProp />);
 
     // The fragment warning is not as severe. For this warning we don't want to
     // pop open a dialog, so we show a collapsed error UI.
@@ -133,125 +118,15 @@ describe('LogBox', () => {
     //   - Pass to console.error, with a "Warning" prefix so it does not pop a RedBox.
     expect(output).toBeDefined();
     expect(mockWarn).not.toBeCalled();
-    expect(console.error).toBeCalledTimes(1);
-    expect(console.error.mock.calls[0]).toEqual([
-      'Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.%s',
-      'invalid',
-      expect.stringMatching('at FragmentWithProp'),
-    ]);
-    expect(spy).toHaveBeenCalledWith({
-      level: 'error',
-      category: expect.stringContaining('Warning: Invalid prop'),
-      componentStack: expect.anything(),
-      componentStackType: expect.stringMatching(/(stack|legacy)/),
-      message: {
-        content:
-          'Warning: Invalid prop `invalid` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.',
-        substitutions: [{length: 7, offset: 23}],
-      },
-    });
-
-    // The Warning: prefix is added due to a hack in LogBox to prevent double logging.
-    // We also interpolate the string before passing to the underlying console method.
-    expect(mockError.mock.calls[0]).toEqual([
-      expect.stringMatching(
-        'Warning: Invalid prop `invalid` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.\n    at FragmentWithProp',
-      ),
-    ]);
-  });
-
-  it('handles a manual console.error without a component stack in LogBox', () => {
-    const LogBox = require('../LogBox').default;
-    const spy = jest.spyOn(LogBox, 'addException');
-    installLogBox();
-
-    // console.error handling depends on installing the ExceptionsManager error reporter.
-    ExceptionsManager.installConsoleErrorReporter();
-
-    // Spy console.error after LogBox is installed
-    // so we can assert on what React logs.
-    jest.spyOn(console, 'error');
-
-    let output;
-    TestRenderer.act(() => {
-      output = TestRenderer.create(<ManualConsoleError />);
-    });
-
-    // Manual console errors should show a collapsed error dialog.
-    // When there is no component stack, we expect these errors to:
-    //   - Go to the LogBox patch and fall through to console.error.
-    //   - Get picked up by the ExceptionsManager console.error override.
-    //   - Get passed back to LogBox via addException (non-fatal).
-    expect(output).toBeDefined();
-    expect(mockWarn).not.toBeCalled();
-    expect(spy).toBeCalledTimes(1);
-    expect(console.error).toBeCalledTimes(1);
-    expect(console.error.mock.calls[0]).toEqual(['Manual console error']);
-    expect(spy).toHaveBeenCalledWith({
-      id: 1,
-      isComponentError: false,
-      isFatal: false,
-      name: 'console.error',
-      originalMessage: 'Manual console error',
-      message: 'console.error: Manual console error',
-      extraData: expect.anything(),
-      componentStack: null,
-      stack: expect.anything(),
-    });
-
-    // No Warning: prefix is added due since this is falling through.
-    expect(mockError.mock.calls[0]).toEqual(['Manual console error']);
-  });
-
-  it('handles a manual console.error with a component stack in LogBox', () => {
-    const spy = jest.spyOn(LogBoxData, 'addLog');
-    installLogBox();
-
-    // console.error handling depends on installing the ExceptionsManager error reporter.
-    ExceptionsManager.installConsoleErrorReporter();
-
-    // Spy console.error after LogBox is installed
-    // so we can assert on what React logs.
-    jest.spyOn(console, 'error');
-
-    let output;
-    TestRenderer.act(() => {
-      output = TestRenderer.create(<ManualConsoleErrorWithStack />);
-    });
-
-    // Manual console errors should show a collapsed error dialog.
-    // When there is a component stack, we expect these errors to:
-    //   - Go to the LogBox patch and be detected as a React error.
-    //   - Check the warning filter to see if there is a fiter setting.
-    //   - Call console.error with the parsed error.
-    //   - Get picked up by ExceptionsManager console.error override.
-    //   - Log to console.error.
-    expect(output).toBeDefined();
-    expect(mockWarn).not.toBeCalled();
-    expect(console.error).toBeCalledTimes(1);
-    expect(spy).toBeCalledTimes(1);
-    expect(console.error.mock.calls[0]).toEqual([
-      expect.stringContaining(
-        'Manual console error\n    at ManualConsoleErrorWithStack',
-      ),
-    ]);
-    expect(spy).toHaveBeenCalledWith({
-      level: 'error',
-      category: expect.stringContaining('Warning: Manual console error'),
-      componentStack: expect.anything(),
-      componentStackType: 'stack',
-      message: {
-        content: 'Warning: Manual console error',
-        substitutions: [],
-      },
-    });
+    expect(console.error.mock.calls[0].map(cleanPath)).toMatchSnapshot(
+      'Log sent from React',
+    );
+    expect(cleanLog(spy.mock.calls[0])).toMatchSnapshot('Log added to LogBox');
+    expect(mockError.mock.calls[0].map(cleanPath)).toMatchSnapshot(
+      'Log passed to console error',
+    );
 
     // The Warning: prefix is added due to a hack in LogBox to prevent double logging.
-    // We also interpolate the string before passing to the underlying console method.
-    expect(mockError.mock.calls[0]).toEqual([
-      expect.stringMatching(
-        'Warning: Manual console error\n    at ManualConsoleErrorWithStack',
-      ),
-    ]);
+    expect(mockError.mock.calls[0][0].startsWith('Warning: ')).toBe(true);
   });
 });