mirror of
https://github.com/zebrajr/react.git
synced 2025-12-07 12:20:38 +01:00
42c3c967d1
* Transform invariant to custom error type
This transforms calls to the invariant module:
```js
invariant(condition, 'A %s message that contains %s', adj, noun);
```
Into throw statements:
```js
if (!condition) {
if (__DEV__) {
throw ReactError(`A ${adj} message that contains ${noun}`);
} else {
throw ReactErrorProd(ERR_CODE, adj, noun);
}
}
```
The only thing ReactError does is return an error whose name is set
to "Invariant Violation" to match the existing behavior.
ReactErrorProd is a special version used in production that throws
a minified error code, with a link to see to expanded form. This
replaces the reactProdInvariant module.
As a next step, I would like to replace our use of the invariant module
for user facing errors by transforming normal Error constructors to
ReactError and ReactErrorProd. (We can continue using invariant for
internal React errors that are meant to be unreachable, which was the
original purpose of invariant.)
* Use numbers instead of strings for error codes
* Use arguments instead of an array
I wasn't sure about this part so I asked Sebastian, and his rationale
was that using arguments will make ReactErrorProd slightly slower, but
using an array will likely make all the functions that throw slightly
slower to compile, so it's hard to say which way is better. But since
ReactErrorProd is in an error path, and fewer bytes is generally better,
no array is good.
* Casing nit
73 lines
2.2 KiB
JavaScript
73 lines
2.2 KiB
JavaScript
/**
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
* @emails react-core
|
|
*/
|
|
'use strict';
|
|
|
|
let React;
|
|
let ReactDOM;
|
|
|
|
describe('ReactError', () => {
|
|
let globalErrorMock;
|
|
|
|
beforeEach(() => {
|
|
if (!__DEV__) {
|
|
// In production, our Jest environment overrides the global Error
|
|
// class in order to decode error messages automatically. However
|
|
// this is a single test where we actually *don't* want to decode
|
|
// them. So we assert that the OriginalError exists, and temporarily
|
|
// set the global Error object back to it.
|
|
globalErrorMock = global.Error;
|
|
global.Error = globalErrorMock.OriginalError;
|
|
expect(typeof global.Error).toBe('function');
|
|
}
|
|
jest.resetModules();
|
|
React = require('react');
|
|
ReactDOM = require('react-dom');
|
|
});
|
|
|
|
afterEach(() => {
|
|
if (!__DEV__) {
|
|
global.Error = globalErrorMock;
|
|
}
|
|
});
|
|
|
|
if (__DEV__) {
|
|
it('should throw errors whose name is "Invariant Violation"', () => {
|
|
let error;
|
|
try {
|
|
React.useState();
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
expect(error.name).toEqual('Invariant Violation');
|
|
});
|
|
} else {
|
|
it('should error with minified error code', () => {
|
|
expect(() => ReactDOM.render('Hi', null)).toThrowError(
|
|
'Minified React error #200; visit ' +
|
|
'https://reactjs.org/docs/error-decoder.html?invariant=200' +
|
|
' for the full message or use the non-minified dev environment' +
|
|
' for full errors and additional helpful warnings.',
|
|
);
|
|
});
|
|
it('should serialize arguments', () => {
|
|
function Oops() {
|
|
return;
|
|
}
|
|
Oops.displayName = '#wtf';
|
|
const container = document.createElement('div');
|
|
expect(() => ReactDOM.render(<Oops />, container)).toThrowError(
|
|
'Minified React error #152; visit ' +
|
|
'https://reactjs.org/docs/error-decoder.html?invariant=152&args[]=%23wtf' +
|
|
' for the full message or use the non-minified dev environment' +
|
|
' for full errors and additional helpful warnings.',
|
|
);
|
|
});
|
|
}
|
|
});
|