/** * 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 JSDOM; let Stream; let Scheduler; let React; let ReactDOMClient; let ReactDOMFizzServer; let Suspense; let SuspenseList; let useSyncExternalStore; let useSyncExternalStoreWithSelector; let PropTypes; let textCache; let window; let document; let writable; let CSPnonce = null; let container; let buffer = ''; let hasErrored = false; let fatalError = undefined; describe('ReactDOMFizzServer', () => { beforeEach(() => { jest.resetModules(); JSDOM = require('jsdom').JSDOM; Scheduler = require('scheduler'); React = require('react'); ReactDOMClient = require('react-dom/client'); if (__EXPERIMENTAL__) { ReactDOMFizzServer = require('react-dom/server'); } Stream = require('stream'); Suspense = React.Suspense; if (gate(flags => flags.enableSuspenseList)) { SuspenseList = React.SuspenseList; } PropTypes = require('prop-types'); if (gate(flags => flags.source)) { // The `with-selector` module composes the main `use-sync-external-store` // entrypoint. In the compiled artifacts, this is resolved to the `shim` // implementation by our build config, but when running the tests against // the source files, we need to tell Jest how to resolve it. Because this // is a source module, this mock has no affect on the build tests. jest.mock('use-sync-external-store/src/useSyncExternalStore', () => jest.requireActual('react'), ); } useSyncExternalStore = React.useSyncExternalStore; useSyncExternalStoreWithSelector = require('use-sync-external-store/with-selector') .useSyncExternalStoreWithSelector; textCache = new Map(); // Test Environment const jsdom = new JSDOM( '
', { runScripts: 'dangerously', }, ); window = jsdom.window; document = jsdom.window.document; container = document.getElementById('container'); buffer = ''; hasErrored = false; writable = new Stream.PassThrough(); writable.setEncoding('utf8'); writable.on('data', chunk => { buffer += chunk; }); writable.on('error', error => { hasErrored = true; fatalError = error; }); }); function expectErrors(errorsArr, toBeDevArr, toBeProdArr) { const mappedErrows = errorsArr.map(({error, errorInfo}) => { const stack = errorInfo && errorInfo.componentStack; const digest = errorInfo && errorInfo.digest; if (stack) { return [error.message, digest, normalizeCodeLocInfo(stack)]; } else if (digest) { return [error.message, digest]; } return error.message; }); if (__DEV__) { expect(mappedErrows).toEqual(toBeDevArr); } else { expect(mappedErrows).toEqual(toBeProdArr); } } function componentStack(components) { return components .map(component => `\n in ${component} (at **)`) .join(''); } async function act(callback) { await callback(); // Await one turn around the event loop. // This assumes that we'll flush everything we have so far. await new Promise(resolve => { setImmediate(resolve); }); if (hasErrored) { throw fatalError; } // JSDOM doesn't support stream HTML parser so we need to give it a proper fragment. // We also want to execute any scripts that are embedded. // We assume that we have now received a proper fragment of HTML. const bufferedContent = buffer; buffer = ''; const fakeBody = document.createElement('body'); fakeBody.innerHTML = bufferedContent; while (fakeBody.firstChild) { const node = fakeBody.firstChild; if ( node.nodeName === 'SCRIPT' && (CSPnonce === null || node.getAttribute('nonce') === CSPnonce) ) { const script = document.createElement('script'); script.textContent = node.textContent; fakeBody.removeChild(node); container.appendChild(script); } else { container.appendChild(node); } } } function getVisibleChildren(element) { const children = []; let node = element.firstChild; while (node) { if (node.nodeType === 1) { if ( node.tagName !== 'SCRIPT' && node.tagName !== 'TEMPLATE' && node.tagName !== 'template' && !node.hasAttribute('hidden') && !node.hasAttribute('aria-hidden') ) { const props = {}; const attributes = node.attributes; for (let i = 0; i < attributes.length; i++) { if ( attributes[i].name === 'id' && attributes[i].value.includes(':') ) { // We assume this is a React added ID that's a non-visual implementation detail. continue; } props[attributes[i].name] = attributes[i].value; } props.children = getVisibleChildren(node); children.push(React.createElement(node.tagName.toLowerCase(), props)); } } else if (node.nodeType === 3) { children.push(node.data); } node = node.nextSibling; } return children.length === 0 ? undefined : children.length === 1 ? children[0] : children; } function resolveText(text) { const record = textCache.get(text); if (record === undefined) { const newRecord = { status: 'resolved', value: text, }; textCache.set(text, newRecord); } else if (record.status === 'pending') { const thenable = record.value; record.status = 'resolved'; record.value = text; thenable.pings.forEach(t => t()); } } function rejectText(text, error) { const record = textCache.get(text); if (record === undefined) { const newRecord = { status: 'rejected', value: error, }; textCache.set(text, newRecord); } else if (record.status === 'pending') { const thenable = record.value; record.status = 'rejected'; record.value = error; thenable.pings.forEach(t => t()); } } function readText(text) { const record = textCache.get(text); if (record !== undefined) { switch (record.status) { case 'pending': throw record.value; case 'rejected': throw record.value; case 'resolved': return record.value; } } else { const thenable = { pings: [], then(resolve) { if (newRecord.status === 'pending') { thenable.pings.push(resolve); } else { Promise.resolve().then(() => resolve(newRecord.value)); } }, }; const newRecord = { status: 'pending', value: thenable, }; textCache.set(text, newRecord); throw thenable; } } function Text({text}) { return text; } function AsyncText({text}) { return readText(text); } function AsyncTextWrapped({as, text}) { const As = as; return {readText(text)}; } // @gate experimental it('should asynchronously load a lazy component', async () => { let resolveA; const LazyA = React.lazy(() => { return new Promise(r => { resolveA = r; }); }); let resolveB; const LazyB = React.lazy(() => { return new Promise(r => { resolveB = r; }); }); function TextWithPunctuation({text, punctuation}) { return ; } // This tests that default props of the inner element is resolved. TextWithPunctuation.defaultProps = { punctuation: '!', }; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
}>
}>
, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
Loading...
, ); await act(async () => { resolveA({default: Text}); }); expect(getVisibleChildren(container)).toEqual(
Hello
Loading...
, ); await act(async () => { resolveB({default: TextWithPunctuation}); }); expect(getVisibleChildren(container)).toEqual(
Hello
world!
, ); }); // @gate experimental it('#23331: does not warn about hydration mismatches if something suspended in an earlier sibling', async () => { const makeApp = () => { let resolve; const imports = new Promise(r => { resolve = () => r({default: () => async}); }); const Lazy = React.lazy(() => imports); const App = () => (
Loading...}> after
); return [App, resolve]; }; // Server-side const [App, resolve] = makeApp(); await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
, ); await act(async () => { resolve(); }); expect(getVisibleChildren(container)).toEqual(
async after
, ); // Client-side const [HydrateApp, hydrateResolve] = makeApp(); await act(async () => { ReactDOMClient.hydrateRoot(container, ); }); expect(getVisibleChildren(container)).toEqual(
async after
, ); await act(async () => { hydrateResolve(); }); expect(getVisibleChildren(container)).toEqual(
async after
, ); }); // @gate experimental it('should support nonce scripts', async () => { CSPnonce = 'R4nd0m'; try { let resolve; const Lazy = React.lazy(() => { return new Promise(r => { resolve = r; }); }); await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
}>
, {nonce: 'R4nd0m'}, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
); await act(async () => { resolve({default: Text}); }); expect(getVisibleChildren(container)).toEqual(
Hello
); } finally { CSPnonce = null; } }); // @gate experimental it('should client render a boundary if a lazy component rejects', async () => { let rejectComponent; const LazyComponent = React.lazy(() => { return new Promise((resolve, reject) => { rejectComponent = reject; }); }); function App({isClient}) { return (
}> {isClient ? : }
); } let bootstrapped = false; const errors = []; window.__INIT__ = function() { bootstrapped = true; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error, errorInfo) { errors.push({error, errorInfo}); }, }); }; const theError = new Error('Test'); const loggedErrors = []; function onError(x) { loggedErrors.push(x); return 'Hash of (' + x.message + ')'; } const expectedDigest = onError(theError); loggedErrors.length = 0; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { bootstrapScriptContent: '__INIT__();', onError, }, ); pipe(writable); }); expect(loggedErrors).toEqual([]); expect(bootstrapped).toBe(true); Scheduler.unstable_flushAll(); // We're still loading because we're waiting for the server to stream more content. expect(getVisibleChildren(container)).toEqual(
Loading...
); expect(loggedErrors).toEqual([]); await act(async () => { rejectComponent(theError); }); expect(loggedErrors).toEqual([theError]); // We haven't ran the client hydration yet. expect(getVisibleChildren(container)).toEqual(
Loading...
); // Now we can client render it instead. expect(Scheduler).toFlushAndYield([]); expectErrors( errors, [ [ theError.message, expectedDigest, componentStack(['Lazy', 'Suspense', 'div', 'App']), ], ], [ [ 'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.', expectedDigest, ], ], ); // The client rendered HTML is now in place. expect(getVisibleChildren(container)).toEqual(
Hello
); expect(loggedErrors).toEqual([theError]); }); // @gate experimental it('should asynchronously load a lazy element', async () => { let resolveElement; const lazyElement = React.lazy(() => { return new Promise(r => { resolveElement = r; }); }); await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
}> {lazyElement}
, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
); // Because there is no content inside the Suspense boundary that could've // been written, we expect to not see any additional partial data flushed // yet. expect(container.firstChild.nextSibling).toBe(null); await act(async () => { resolveElement({default: }); }); expect(getVisibleChildren(container)).toEqual(
Hello
); }); // @gate experimental it('should client render a boundary if a lazy element rejects', async () => { let rejectElement; const element = ; const lazyElement = React.lazy(() => { return new Promise((resolve, reject) => { rejectElement = reject; }); }); const theError = new Error('Test'); const loggedErrors = []; function onError(x) { loggedErrors.push(x); return 'hash of (' + x.message + ')'; } const expectedDigest = onError(theError); loggedErrors.length = 0; function App({isClient}) { return (
}> {isClient ? element : lazyElement}
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError, }, ); pipe(writable); }); expect(loggedErrors).toEqual([]); const errors = []; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error, errorInfo) { errors.push({error, errorInfo}); }, }); Scheduler.unstable_flushAll(); // We're still loading because we're waiting for the server to stream more content. expect(getVisibleChildren(container)).toEqual(
Loading...
); expect(loggedErrors).toEqual([]); await act(async () => { rejectElement(theError); }); expect(loggedErrors).toEqual([theError]); // We haven't ran the client hydration yet. expect(getVisibleChildren(container)).toEqual(
Loading...
); // Now we can client render it instead. expect(Scheduler).toFlushAndYield([]); expectErrors( errors, [ [ theError.message, expectedDigest, componentStack(['Suspense', 'div', 'App']), ], ], [ [ 'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.', expectedDigest, ], ], ); // The client rendered HTML is now in place. // expect(getVisibleChildren(container)).toEqual(
Hello
); expect(loggedErrors).toEqual([theError]); }); // @gate experimental it('Errors in boundaries should be sent to the client and reported on client render - Error before flushing', async () => { function Indirection({level, children}) { if (level > 0) { return {children}; } return children; } const theError = new Error('uh oh'); function Erroring({isClient}) { if (isClient) { return 'Hello World'; } throw theError; } function App({isClient}) { return (
loading...}>
); } const loggedErrors = []; function onError(x) { loggedErrors.push(x); return 'hash(' + x.message + ')'; } const expectedDigest = onError(theError); loggedErrors.length = 0; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError, }, ); pipe(writable); }); expect(loggedErrors).toEqual([theError]); const errors = []; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error, errorInfo) { errors.push({error, errorInfo}); }, }); Scheduler.unstable_flushAll(); expect(getVisibleChildren(container)).toEqual(
Hello World
); expectErrors( errors, [ [ theError.message, expectedDigest, componentStack(['Erroring', 'Suspense', 'div', 'App']), ], ], [ [ 'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.', expectedDigest, ], ], ); }); // @gate experimental it('Errors in boundaries should be sent to the client and reported on client render - Error after flushing', async () => { let rejectComponent; const LazyComponent = React.lazy(() => { return new Promise((resolve, reject) => { rejectComponent = reject; }); }); function App({isClient}) { return (
}> {isClient ? : }
); } const loggedErrors = []; const theError = new Error('uh oh'); function onError(x) { loggedErrors.push(x); return 'hash(' + x.message + ')'; } const expectedDigest = onError(theError); loggedErrors.length = 0; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError, }, ); pipe(writable); }); expect(loggedErrors).toEqual([]); const errors = []; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error, errorInfo) { errors.push({error, errorInfo}); }, }); Scheduler.unstable_flushAll(); expect(getVisibleChildren(container)).toEqual(
Loading...
); await act(async () => { rejectComponent(theError); }); expect(loggedErrors).toEqual([theError]); expect(getVisibleChildren(container)).toEqual(
Loading...
); // Now we can client render it instead. expect(Scheduler).toFlushAndYield([]); expectErrors( errors, [ [ theError.message, expectedDigest, componentStack(['Lazy', 'Suspense', 'div', 'App']), ], ], [ [ 'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.', expectedDigest, ], ], ); // The client rendered HTML is now in place. expect(getVisibleChildren(container)).toEqual(
Hello
); expect(loggedErrors).toEqual([theError]); }); // @gate experimental it('should asynchronously load the suspense boundary', async () => { await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
}>
, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
); await act(async () => { resolveText('Hello World'); }); expect(getVisibleChildren(container)).toEqual(
Hello World
); }); // @gate experimental it('waits for pending content to come in from the server and then hydrates it', async () => { const ref = React.createRef(); function App() { return (

); } let bootstrapped = false; window.__INIT__ = function() { bootstrapped = true; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, ); }; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(, { bootstrapScriptContent: '__INIT__();', }); pipe(writable); }); // We're still showing a fallback. expect(getVisibleChildren(container)).toEqual(
Loading...
); // We already bootstrapped. expect(bootstrapped).toBe(true); // Attempt to hydrate the content. Scheduler.unstable_flushAll(); // We're still loading because we're waiting for the server to stream more content. expect(getVisibleChildren(container)).toEqual(
Loading...
); // The server now updates the content in place in the fallback. await act(async () => { resolveText('Hello'); }); // The final HTML is now in place. expect(getVisibleChildren(container)).toEqual(

Hello

, ); const h1 = container.getElementsByTagName('h1')[0]; // But it is not yet hydrated. expect(ref.current).toBe(null); Scheduler.unstable_flushAll(); // Now it's hydrated. expect(ref.current).toBe(h1); }); // @gate experimental it('handles an error on the client if the server ends up erroring', async () => { const ref = React.createRef(); class ErrorBoundary extends React.Component { state = {error: null}; static getDerivedStateFromError(error) { return {error}; } render() { if (this.state.error) { return {this.state.error.message}; } return this.props.children; } } function App() { return (
); } const loggedErrors = []; // We originally suspend the boundary and start streaming the loading state. await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError(x) { loggedErrors.push(x); }, }, ); pipe(writable); }); // We're still showing a fallback. expect(getVisibleChildren(container)).toEqual(
Loading...
); expect(loggedErrors).toEqual([]); // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, ); Scheduler.unstable_flushAll(); // We're still loading because we're waiting for the server to stream more content. expect(getVisibleChildren(container)).toEqual(
Loading...
); const theError = new Error('Error Message'); await act(async () => { rejectText('This Errors', theError); }); expect(loggedErrors).toEqual([theError]); // The server errored, but we still haven't hydrated. We don't know if the // client will succeed yet, so we still show the loading state. expect(getVisibleChildren(container)).toEqual(
Loading...
); expect(ref.current).toBe(null); // Flush the hydration. Scheduler.unstable_flushAll(); // Hydrating should've generated an error and replaced the suspense boundary. expect(getVisibleChildren(container)).toEqual(Error Message); const b = container.getElementsByTagName('b')[0]; expect(ref.current).toBe(b); }); // @gate enableSuspenseList // @gate experimental it('shows inserted items before pending in a SuspenseList as fallbacks while hydrating', async () => { const ref = React.createRef(); // These are hoisted to avoid them from rerendering. const a = ( ); const b = ( ); function App({showMore}) { return ( {a} {b} {showMore ? ( C ) : null} ); } // We originally suspend the boundary and start streaming the loading state. await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , ); pipe(writable); }); const root = ReactDOMClient.hydrateRoot( container, , ); Scheduler.unstable_flushAll(); // We're not hydrated yet. expect(ref.current).toBe(null); expect(getVisibleChildren(container)).toEqual([ 'Loading A', // TODO: This is incorrect. It should be "Loading B" but Fizz SuspenseList // isn't implemented fully yet. B, ]); // Add more rows before we've hydrated the first two. root.render(); Scheduler.unstable_flushAll(); // We're not hydrated yet. expect(ref.current).toBe(null); // We haven't resolved yet. expect(getVisibleChildren(container)).toEqual([ 'Loading A', // TODO: This is incorrect. It should be "Loading B" but Fizz SuspenseList // isn't implemented fully yet. B, 'Loading C', ]); await act(async () => { await resolveText('A'); }); Scheduler.unstable_flushAll(); expect(getVisibleChildren(container)).toEqual([ A, B, C, ]); const span = container.getElementsByTagName('span')[0]; expect(ref.current).toBe(span); }); // @gate experimental it('client renders a boundary if it does not resolve before aborting', async () => { function App() { return (

); } const loggedErrors = []; const expectedDigest = 'Hash for Abort'; function onError(error) { loggedErrors.push(error); return expectedDigest; } let controls; await act(async () => { controls = ReactDOMFizzServer.renderToPipeableStream(, {onError}); controls.pipe(writable); }); // We're still showing a fallback. const errors = []; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error, errorInfo) { errors.push({error, errorInfo}); }, }); Scheduler.unstable_flushAll(); // We're still loading because we're waiting for the server to stream more content. expect(getVisibleChildren(container)).toEqual(
Loading...
); // We abort the server response. await act(async () => { controls.abort(); }); // We still can't render it on the client. expect(Scheduler).toFlushAndYield([]); expectErrors( errors, [['This Suspense boundary was aborted by the server.', expectedDigest]], [ [ 'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.', expectedDigest, ], ], ); expect(getVisibleChildren(container)).toEqual(
Loading...
); // We now resolve it on the client. resolveText('Hello'); Scheduler.unstable_flushAll(); // The client rendered HTML is now in place. expect(getVisibleChildren(container)).toEqual(

Hello

, ); }); // @gate experimental it('should allow for two containers to be written to the same document', async () => { // We create two passthrough streams for each container to write into. // Notably we don't implement a end() call for these. Because we don't want to // close the underlying stream just because one of the streams is done. Instead // we manually close when both are done. const writableA = new Stream.Writable(); writableA._write = (chunk, encoding, next) => { writable.write(chunk, encoding, next); }; const writableB = new Stream.Writable(); writableB._write = (chunk, encoding, next) => { writable.write(chunk, encoding, next); }; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( // We use two nested boundaries to flush out coverage of an old reentrancy bug. }> <>
, { identifierPrefix: 'A_', onShellReady() { writableA.write('
'); pipe(writableA); writableA.write('
'); }, }, ); }); await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( }>
, { identifierPrefix: 'B_', onShellReady() { writableB.write('
'); pipe(writableB); writableB.write('
'); }, }, ); }); expect(getVisibleChildren(container)).toEqual([
Loading A...
,
Loading B...
, ]); await act(async () => { resolveText('B'); }); expect(getVisibleChildren(container)).toEqual([
Loading A...
,
This will show B:
B
, ]); await act(async () => { resolveText('A'); }); // We're done writing both streams now. writable.end(); expect(getVisibleChildren(container)).toEqual([
This will show A:
A
,
This will show B:
B
, ]); }); // @gate experimental it('can resolve async content in esoteric parents', async () => { function AsyncOption({text}) { return ; } function AsyncCol({className}) { return ; } function AsyncPath({id}) { return ; } function AsyncMi({id}) { return ; } function App() { return (
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
, ); await act(async () => { resolveText('Hello'); }); await act(async () => { resolveText('World'); }); await act(async () => { resolveText('my-path'); resolveText('my-mi'); }); expect(getVisibleChildren(container)).toEqual(
, ); expect(container.querySelector('#my-path').namespaceURI).toBe( 'http://www.w3.org/2000/svg', ); expect(container.querySelector('#my-mi').namespaceURI).toBe( 'http://www.w3.org/1998/Math/MathML', ); }); // @gate experimental it('can resolve async content in table parents', async () => { function AsyncTableBody({className, children}) { return {children}; } function AsyncTableRow({className, children}) { return {children}; } function AsyncTableCell({text}) { return {readText(text)}; } function App() { return ( }>
Loading...
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading...
, ); await act(async () => { resolveText('A'); }); await act(async () => { resolveText('B'); }); await act(async () => { resolveText('C'); }); expect(getVisibleChildren(container)).toEqual(
C
, ); }); // @gate experimental it('can stream into an SVG container', async () => { function AsyncPath({id}) { return ; } function App() { return ( Loading...
}> ); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { namespaceURI: 'http://www.w3.org/2000/svg', onShellReady() { writable.write(''); pipe(writable); writable.write(''); }, }, ); }); expect(getVisibleChildren(container)).toEqual( Loading... , ); await act(async () => { resolveText('my-path'); }); expect(getVisibleChildren(container)).toEqual( , ); expect(container.querySelector('#my-path').namespaceURI).toBe( 'http://www.w3.org/2000/svg', ); }); function normalizeCodeLocInfo(str) { return ( str && str.replace(/\n +(?:at|in) ([\S]+)[^\n]*/g, function(m, name) { return '\n in ' + name + ' (at **)'; }) ); } // @gate experimental it('should include a component stack across suspended boundaries', async () => { function B() { const children = [readText('Hello'), readText('World')]; // Intentionally trigger a key warning here. return (
{children.map(t => ( {t} ))}
); } function C() { return ( ); } function A() { return (
}>
); } // We can't use the toErrorDev helper here because this is an async act. const originalConsoleError = console.error; const mockError = jest.fn(); console.error = (...args) => { mockError(...args.map(normalizeCodeLocInfo)); }; try { await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading
, ); if (__DEV__) { expect(mockError).toHaveBeenCalledWith( 'Warning: <%s /> is using incorrect casing. Use PascalCase for React components, or lowercase for HTML elements.%s', 'inCorrectTag', '\n' + ' in inCorrectTag (at **)\n' + ' in C (at **)\n' + ' in Suspense (at **)\n' + ' in div (at **)\n' + ' in A (at **)', ); mockError.mockClear(); } else { expect(mockError).not.toHaveBeenCalled(); } await act(async () => { resolveText('Hello'); resolveText('World'); }); if (__DEV__) { expect(mockError).toHaveBeenCalledWith( 'Warning: Each child in a list should have a unique "key" prop.%s%s' + ' See https://reactjs.org/link/warning-keys for more information.%s', '\n\nCheck the top-level render call using
.', '', '\n' + ' in span (at **)\n' + ' in B (at **)\n' + ' in Suspense (at **)\n' + ' in div (at **)\n' + ' in A (at **)', ); } else { expect(mockError).not.toHaveBeenCalled(); } expect(getVisibleChildren(container)).toEqual(
Hello World
, ); } finally { console.error = originalConsoleError; } }); // @gate experimental it('should can suspend in a class component with legacy context', async () => { class TestProvider extends React.Component { static childContextTypes = { test: PropTypes.string, }; state = {ctxToSet: null}; static getDerivedStateFromProps(props, state) { return {ctxToSet: props.ctx}; } getChildContext() { return { test: this.state.ctxToSet, }; } render() { return this.props.children; } } class TestConsumer extends React.Component { static contextTypes = { test: PropTypes.string, }; render() { const child = ( ); if (this.props.prefix) { return [readText(this.props.prefix), child]; } return child; } } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
, ]}>
, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
Loading: A
, ); await act(async () => { resolveText('Hello: '); }); expect(getVisibleChildren(container)).toEqual(
Hello: B A
, ); }); // @gate experimental it('should resume the context from where it left off', async () => { const ContextA = React.createContext('A0'); const ContextB = React.createContext('B0'); function PrintA() { return ( {value => } ); } class PrintB extends React.Component { static contextType = ContextB; render() { return ; } } function AsyncParent({text, children}) { return ( <> {children} ); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
}>
, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
A0
Loading...
A0
, ); await act(async () => { resolveText('Child:'); }); expect(getVisibleChildren(container)).toEqual(
A0
Child:A0.1B0
A0
, ); }); // @gate experimental it('should recover the outer context when an error happens inside a provider', async () => { const ContextA = React.createContext('A0'); const ContextB = React.createContext('B0'); function PrintA() { return ( {value => } ); } class PrintB extends React.Component { static contextType = ContextB; render() { return ; } } function Throws() { const value = React.useContext(ContextA); throw new Error(value); } const loggedErrors = []; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
}>
, { onError(x) { loggedErrors.push(x); }, }, ); pipe(writable); }); expect(loggedErrors.length).toBe(1); expect(loggedErrors[0].message).toEqual('A0.1.1'); expect(getVisibleChildren(container)).toEqual(
A0
Loading...B0
A0
, ); }); // @gate experimental it('client renders a boundary if it errors before finishing the fallback', async () => { function App({isClient}) { return (
}>

{isClient ? : }

); } const theError = new Error('Test'); const loggedErrors = []; function onError(x) { loggedErrors.push(x); return `hash of (${x.message})`; } const expectedDigest = onError(theError); loggedErrors.length = 0; let controls; await act(async () => { controls = ReactDOMFizzServer.renderToPipeableStream( , { onError, }, ); controls.pipe(writable); }); // We're still showing a fallback. const errors = []; // Attempt to hydrate the content. ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error, errorInfo) { errors.push({error, errorInfo}); }, }); Scheduler.unstable_flushAll(); // We're still loading because we're waiting for the server to stream more content. expect(getVisibleChildren(container)).toEqual('Loading root...'); expect(loggedErrors).toEqual([]); // Error the content, but we don't have a fallback yet. await act(async () => { rejectText('Hello', theError); }); expect(loggedErrors).toEqual([theError]); // We still can't render it on the client because we haven't unblocked the parent. Scheduler.unstable_flushAll(); expect(getVisibleChildren(container)).toEqual('Loading root...'); // Unblock the loading state await act(async () => { resolveText('Loading...'); }); // Now we're able to show the inner boundary. expect(getVisibleChildren(container)).toEqual(
Loading...
); // That will let us client render it instead. expect(Scheduler).toFlushAndYield([]); expectErrors( errors, [ [ theError.message, expectedDigest, componentStack([ 'AsyncText', 'h1', 'Suspense', 'div', 'Suspense', 'App', ]), ], ], [ [ 'The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering.', expectedDigest, ], ], ); // The client rendered HTML is now in place. expect(getVisibleChildren(container)).toEqual(

Hello

, ); expect(loggedErrors).toEqual([theError]); }); // @gate experimental it('should be able to abort the fallback if the main content finishes first', async () => { await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( }>
Inner
}>
, ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual('Loading Outer'); // We should have received a partial segment containing the a partial of the fallback. expect(container.innerHTML).toContain('Inner'); await act(async () => { resolveText('Hello'); }); // We should've been able to display the content without waiting for the rest of the fallback. expect(getVisibleChildren(container)).toEqual(
Hello
); }); // @gate experimental && enableSuspenseAvoidThisFallbackFizz it('should respect unstable_avoidThisFallback', async () => { const resolved = { 0: false, 1: false, }; const promiseRes = {}; const promises = { 0: new Promise(res => { promiseRes[0] = () => { resolved[0] = true; res(); }; }), 1: new Promise(res => { promiseRes[1] = () => { resolved[1] = true; res(); }; }), }; const InnerComponent = ({isClient, depth}) => { if (isClient) { // Resuspend after re-rendering on client to check that fallback shows on client throw new Promise(() => {}); } if (!resolved[depth]) { throw promises[depth]; } return (
); }; function App({isClient}) { return (
} unstable_avoidThisFallback={true}>
}> } unstable_avoidThisFallback={true}>
); } await jest.runAllTimers(); await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , ); pipe(writable); }); // Nothing is output since root has a suspense with avoidedThisFallback that hasn't resolved expect(getVisibleChildren(container)).toEqual(undefined); expect(container.innerHTML).not.toContain('Avoided Fallback'); // resolve first suspense component with avoidThisFallback await act(async () => { promiseRes[0](); }); expect(getVisibleChildren(container)).toEqual(
Non Suspense Content
resolved 0
Fallback
, ); expect(container.innerHTML).not.toContain('Avoided Fallback2'); await act(async () => { promiseRes[1](); }); expect(getVisibleChildren(container)).toEqual(
Non Suspense Content
resolved 0
resolved 1
, ); let root; await act(async () => { root = ReactDOMClient.hydrateRoot(container, ); Scheduler.unstable_flushAll(); await jest.runAllTimers(); }); // No change after hydration expect(getVisibleChildren(container)).toEqual(
Non Suspense Content
resolved 0
resolved 1
, ); await act(async () => { // Trigger update by changing isClient to true root.render(); Scheduler.unstable_flushAll(); await jest.runAllTimers(); }); // Now that we've resuspended at the root we show the root fallback expect(getVisibleChildren(container)).toEqual(
Non Suspense Content
resolved 0
resolved 1
Avoided Fallback
, ); }); // @gate experimental it('calls getServerSnapshot instead of getSnapshot', async () => { const ref = React.createRef(); function getServerSnapshot() { return 'server'; } function getClientSnapshot() { return 'client'; } function subscribe() { return () => {}; } function Child({text}) { Scheduler.unstable_yieldValue(text); return text; } function App() { const value = useSyncExternalStore( subscribe, getClientSnapshot, getServerSnapshot, ); return (
); } const loggedErrors = []; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError(x) { loggedErrors.push(x); }, }, ); pipe(writable); }); expect(Scheduler).toHaveYielded(['server']); ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue( 'Log recoverable error: ' + error.message, ); }, }); expect(() => { // The first paint switches to client rendering due to mismatch expect(Scheduler).toFlushUntilNextPaint([ 'client', 'Log recoverable error: Hydration failed because the initial ' + 'UI does not match what was rendered on the server.', 'Log recoverable error: There was an error while hydrating. ' + 'Because the error happened outside of a Suspense boundary, the ' + 'entire root will switch to client rendering.', ]); }).toErrorDev( [ 'Warning: An error occurred during hydration. The server HTML was replaced with client content in
.', 'Warning: Expected server HTML to contain a matching
in
.\n' + ' in div (at **)\n' + ' in App (at **)', ], {withoutStack: 1}, ); expect(getVisibleChildren(container)).toEqual(
client
); }); // The selector implementation uses the lazy ref initialization pattern // @gate experimental it('calls getServerSnapshot instead of getSnapshot (with selector and isEqual)', async () => { // Same as previous test, but with a selector that returns a complex object // that is memoized with a custom `isEqual` function. const ref = React.createRef(); function getServerSnapshot() { return {env: 'server', other: 'unrelated'}; } function getClientSnapshot() { return {env: 'client', other: 'unrelated'}; } function selector({env}) { return {env}; } function isEqual(a, b) { return a.env === b.env; } function subscribe() { return () => {}; } function Child({text}) { Scheduler.unstable_yieldValue(text); return text; } function App() { const {env} = useSyncExternalStoreWithSelector( subscribe, getClientSnapshot, getServerSnapshot, selector, isEqual, ); return (
); } const loggedErrors = []; await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError(x) { loggedErrors.push(x); }, }, ); pipe(writable); }); expect(Scheduler).toHaveYielded(['server']); ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue( 'Log recoverable error: ' + error.message, ); }, }); // The first paint uses the client due to mismatch forcing client render expect(() => { // The first paint switches to client rendering due to mismatch expect(Scheduler).toFlushUntilNextPaint([ 'client', 'Log recoverable error: Hydration failed because the initial ' + 'UI does not match what was rendered on the server.', 'Log recoverable error: There was an error while hydrating. ' + 'Because the error happened outside of a Suspense boundary, the ' + 'entire root will switch to client rendering.', ]); }).toErrorDev( [ 'Warning: An error occurred during hydration. The server HTML was replaced with client content', 'Warning: Expected server HTML to contain a matching
in
.\n' + ' in div (at **)\n' + ' in App (at **)', ], {withoutStack: 1}, ); expect(getVisibleChildren(container)).toEqual(
client
); }); // @gate experimental it( 'errors during hydration in the shell force a client render at the ' + 'root, and during the client render it recovers', async () => { let isClient = false; function subscribe() { return () => {}; } function getClientSnapshot() { return 'Yay!'; } // At the time of writing, the only API that exposes whether it's currently // hydrating is the `getServerSnapshot` API, so I'm using that here to // simulate an error during hydration. function getServerSnapshot() { if (isClient) { throw new Error('Hydration error'); } return 'Yay!'; } function Child() { const value = useSyncExternalStore( subscribe, getClientSnapshot, getServerSnapshot, ); Scheduler.unstable_yieldValue(value); return value; } const spanRef = React.createRef(); function App() { return ( ); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(Scheduler).toHaveYielded(['Yay!']); const span = container.getElementsByTagName('span')[0]; // Hydrate the tree. Child will throw during hydration, but not when it // falls back to client rendering. isClient = true; ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue(error.message); }, }); // An error logged but instead of surfacing it to the UI, we switched // to client rendering. expect(() => { expect(Scheduler).toFlushAndYield([ 'Yay!', 'Hydration error', 'There was an error while hydrating. Because the error happened ' + 'outside of a Suspense boundary, the entire root will switch ' + 'to client rendering.', ]); }).toErrorDev( 'An error occurred during hydration. The server HTML was replaced', {withoutStack: true}, ); expect(getVisibleChildren(container)).toEqual(Yay!); // The node that's inside the boundary that errored during hydration was // not hydrated. expect(spanRef.current).not.toBe(span); }, ); // @gate experimental it( 'errors during hydration force a client render at the nearest Suspense ' + 'boundary, and during the client render it recovers', async () => { let isClient = false; function subscribe() { return () => {}; } function getClientSnapshot() { return 'Yay!'; } // At the time of writing, the only API that exposes whether it's currently // hydrating is the `getServerSnapshot` API, so I'm using that here to // simulate an error during hydration. function getServerSnapshot() { if (isClient) { throw new Error('Hydration error'); } return 'Yay!'; } function Child() { const value = useSyncExternalStore( subscribe, getClientSnapshot, getServerSnapshot, ); Scheduler.unstable_yieldValue(value); return value; } const span1Ref = React.createRef(); const span2Ref = React.createRef(); const span3Ref = React.createRef(); function App() { return (
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(Scheduler).toHaveYielded(['Yay!']); const [span1, span2, span3] = container.getElementsByTagName('span'); // Hydrate the tree. Child will throw during hydration, but not when it // falls back to client rendering. isClient = true; ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue(error.message); }, }); // An error logged but instead of surfacing it to the UI, we switched // to client rendering. expect(Scheduler).toFlushAndYield([ 'Yay!', 'Hydration error', 'There was an error while hydrating this Suspense boundary. Switched to client rendering.', ]); expect(getVisibleChildren(container)).toEqual(
Yay!
, ); // The node that's inside the boundary that errored during hydration was // not hydrated. expect(span2Ref.current).not.toBe(span2); // But the nodes outside the boundary were. expect(span1Ref.current).toBe(span1); expect(span3Ref.current).toBe(span3); }, ); // @gate experimental it( 'errors during hydration force a client render at the nearest Suspense ' + 'boundary, and during the client render it fails again', async () => { // Similar to previous test, but the client render errors, too. We should // be able to capture it with an error boundary. let isClient = false; class ErrorBoundary extends React.Component { state = {error: null}; static getDerivedStateFromError(error) { return {error}; } render() { if (this.state.error !== null) { return this.state.error.message; } return this.props.children; } } function Child() { if (isClient) { throw new Error('Oops!'); } Scheduler.unstable_yieldValue('Yay!'); return 'Yay!'; } const span1Ref = React.createRef(); const span2Ref = React.createRef(); const span3Ref = React.createRef(); function App() { return ( ); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(Scheduler).toHaveYielded(['Yay!']); // Hydrate the tree. Child will throw during render. isClient = true; const errors = []; ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { errors.push(error.message); }, }); // Because we failed to recover from the error, onRecoverableError // shouldn't be called. expect(Scheduler).toFlushAndYield([]); expect(getVisibleChildren(container)).toEqual('Oops!'); expectErrors(errors, [], []); }, ); // Disabled because of a WWW late mutations regression. // We may want to re-enable this if we figure out why. // @gate experimental // @gate FIXME it('does not recreate the fallback if server errors and hydration suspends', async () => { let isClient = false; function Child() { if (isClient) { readText('Yay!'); } else { throw Error('Oops.'); } Scheduler.unstable_yieldValue('Yay!'); return 'Yay!'; } const fallbackRef = React.createRef(); function App() { return (
Loading...

}>
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(, { onError(error) { Scheduler.unstable_yieldValue('[s!] ' + error.message); }, }); pipe(writable); }); expect(Scheduler).toHaveYielded(['[s!] Oops.']); // The server could not complete this boundary, so we'll retry on the client. const serverFallback = container.getElementsByTagName('p')[0]; expect(serverFallback.innerHTML).toBe('Loading...'); // Hydrate the tree. This will suspend. isClient = true; ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue('[c!] ' + error.message); }, }); // This should not report any errors yet. expect(Scheduler).toFlushAndYield([]); expect(getVisibleChildren(container)).toEqual(

Loading...

, ); // Normally, hydrating after server error would force a clean client render. // However, it suspended so at best we'd only get the same fallback anyway. // We don't want to recreate the same fallback in the DOM again because // that's extra work and would restart animations etc. Check we don't do that. const clientFallback = container.getElementsByTagName('p')[0]; expect(serverFallback).toBe(clientFallback); // When we're able to fully hydrate, we expect a clean client render. await act(async () => { resolveText('Yay!'); }); expect(Scheduler).toFlushAndYield([ 'Yay!', '[c!] The server could not finish this Suspense boundary, ' + 'likely due to an error during server rendering. ' + 'Switched to client rendering.', ]); expect(getVisibleChildren(container)).toEqual(
Yay!
, ); }); // Disabled because of a WWW late mutations regression. // We may want to re-enable this if we figure out why. // @gate experimental // @gate FIXME it( 'does not recreate the fallback if server errors and hydration suspends ' + 'and root receives a transition', async () => { let isClient = false; function Child({color}) { if (isClient) { readText('Yay!'); } else { throw Error('Oops.'); } Scheduler.unstable_yieldValue('Yay! (' + color + ')'); return 'Yay! (' + color + ')'; } const fallbackRef = React.createRef(); function App({color}) { return (
Loading...

}>
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError(error) { Scheduler.unstable_yieldValue('[s!] ' + error.message); }, }, ); pipe(writable); }); expect(Scheduler).toHaveYielded(['[s!] Oops.']); // The server could not complete this boundary, so we'll retry on the client. const serverFallback = container.getElementsByTagName('p')[0]; expect(serverFallback.innerHTML).toBe('Loading...'); // Hydrate the tree. This will suspend. isClient = true; const root = ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue('[c!] ' + error.message); }, }); // This should not report any errors yet. expect(Scheduler).toFlushAndYield([]); expect(getVisibleChildren(container)).toEqual(

Loading...

, ); // Normally, hydrating after server error would force a clean client render. // However, it suspended so at best we'd only get the same fallback anyway. // We don't want to recreate the same fallback in the DOM again because // that's extra work and would restart animations etc. Check we don't do that. const clientFallback = container.getElementsByTagName('p')[0]; expect(serverFallback).toBe(clientFallback); // Transition updates shouldn't recreate the fallback either. React.startTransition(() => { root.render(); }); Scheduler.unstable_flushAll(); jest.runAllTimers(); const clientFallback2 = container.getElementsByTagName('p')[0]; expect(clientFallback2).toBe(serverFallback); // When we're able to fully hydrate, we expect a clean client render. await act(async () => { resolveText('Yay!'); }); expect(Scheduler).toFlushAndYield([ 'Yay! (red)', '[c!] The server could not finish this Suspense boundary, ' + 'likely due to an error during server rendering. ' + 'Switched to client rendering.', 'Yay! (blue)', ]); expect(getVisibleChildren(container)).toEqual(
Yay! (blue)
, ); }, ); // Disabled because of a WWW late mutations regression. // We may want to re-enable this if we figure out why. // @gate experimental // @gate FIXME it( 'recreates the fallback if server errors and hydration suspends but ' + 'client receives new props', async () => { let isClient = false; function Child() { const value = 'Yay!'; if (isClient) { readText(value); } else { throw Error('Oops.'); } Scheduler.unstable_yieldValue(value); return value; } const fallbackRef = React.createRef(); function App({fallbackText}) { return (
{fallbackText}

}>
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream( , { onError(error) { Scheduler.unstable_yieldValue('[s!] ' + error.message); }, }, ); pipe(writable); }); expect(Scheduler).toHaveYielded(['[s!] Oops.']); const serverFallback = container.getElementsByTagName('p')[0]; expect(serverFallback.innerHTML).toBe('Loading...'); // Hydrate the tree. This will suspend. isClient = true; const root = ReactDOMClient.hydrateRoot( container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue('[c!] ' + error.message); }, }, ); // This should not report any errors yet. expect(Scheduler).toFlushAndYield([]); expect(getVisibleChildren(container)).toEqual(

Loading...

, ); // Normally, hydration after server error would force a clean client render. // However, that suspended so at best we'd only get a fallback anyway. // We don't want to replace a fallback with the same fallback because // that's extra work and would restart animations etc. Verify we don't do that. const clientFallback1 = container.getElementsByTagName('p')[0]; expect(serverFallback).toBe(clientFallback1); // However, an update may have changed the fallback props. In that case we have to // actually force it to re-render on the client and throw away the server one. root.render(); Scheduler.unstable_flushAll(); jest.runAllTimers(); expect(Scheduler).toHaveYielded([ '[c!] The server could not finish this Suspense boundary, ' + 'likely due to an error during server rendering. ' + 'Switched to client rendering.', ]); expect(getVisibleChildren(container)).toEqual(

More loading...

, ); // This should be a clean render without reusing DOM. const clientFallback2 = container.getElementsByTagName('p')[0]; expect(clientFallback2).not.toBe(clientFallback1); // Verify we can still do a clean content render after. await act(async () => { resolveText('Yay!'); }); expect(Scheduler).toFlushAndYield(['Yay!']); expect(getVisibleChildren(container)).toEqual(
Yay!
, ); }, ); // @gate experimental it( 'errors during hydration force a client render at the nearest Suspense ' + 'boundary, and during the client render it recovers, then a deeper ' + 'child suspends', async () => { let isClient = false; function subscribe() { return () => {}; } function getClientSnapshot() { return 'Yay!'; } // At the time of writing, the only API that exposes whether it's currently // hydrating is the `getServerSnapshot` API, so I'm using that here to // simulate an error during hydration. function getServerSnapshot() { if (isClient) { throw new Error('Hydration error'); } return 'Yay!'; } function Child() { const value = useSyncExternalStore( subscribe, getClientSnapshot, getServerSnapshot, ); if (isClient) { readText(value); } Scheduler.unstable_yieldValue(value); return value; } const span1Ref = React.createRef(); const span2Ref = React.createRef(); const span3Ref = React.createRef(); function App() { return (
); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(Scheduler).toHaveYielded(['Yay!']); const [span1, span2, span3] = container.getElementsByTagName('span'); // Hydrate the tree. Child will throw during hydration, but not when it // falls back to client rendering. isClient = true; ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue(error.message); }, }); // An error logged but instead of surfacing it to the UI, we switched // to client rendering. expect(Scheduler).toFlushAndYield([ 'Hydration error', 'There was an error while hydrating this Suspense boundary. Switched ' + 'to client rendering.', ]); expect(getVisibleChildren(container)).toEqual(
Loading...
, ); await act(async () => { resolveText('Yay!'); }); expect(Scheduler).toFlushAndYield(['Yay!']); expect(getVisibleChildren(container)).toEqual(
Yay!
, ); // The node that's inside the boundary that errored during hydration was // not hydrated. expect(span2Ref.current).not.toBe(span2); // But the nodes outside the boundary were. expect(span1Ref.current).toBe(span1); expect(span3Ref.current).toBe(span3); }, ); it('logs regular (non-hydration) errors when the UI recovers', async () => { let shouldThrow = true; function A() { if (shouldThrow) { Scheduler.unstable_yieldValue('Oops!'); throw new Error('Oops!'); } Scheduler.unstable_yieldValue('A'); return 'A'; } function B() { Scheduler.unstable_yieldValue('B'); return 'B'; } function App() { return ( <>
); } const root = ReactDOMClient.createRoot(container, { onRecoverableError(error) { Scheduler.unstable_yieldValue( 'Logged a recoverable error: ' + error.message, ); }, }); React.startTransition(() => { root.render(); }); // Partially render A, but yield before the render has finished expect(Scheduler).toFlushAndYieldThrough(['Oops!', 'Oops!']); // React will try rendering again synchronously. During the retry, A will // not throw. This simulates a concurrent data race that is fixed by // blocking the main thread. shouldThrow = false; expect(Scheduler).toFlushAndYield([ // Finish initial render attempt 'B', // Render again, synchronously 'A', 'B', // Log the error 'Logged a recoverable error: Oops!', ]); // UI looks normal expect(container.textContent).toEqual('AB'); }); // @gate experimental it('logs multiple hydration errors in the same render', async () => { let isClient = false; function subscribe() { return () => {}; } function getClientSnapshot() { return 'Yay!'; } function getServerSnapshot() { if (isClient) { throw new Error('Hydration error'); } return 'Yay!'; } function Child({label}) { // This will throw during client hydration. Only reason to use // useSyncExternalStore in this test is because getServerSnapshot has the // ability to observe whether we're hydrating. useSyncExternalStore(subscribe, getClientSnapshot, getServerSnapshot); Scheduler.unstable_yieldValue(label); return label; } function App() { return ( <> ); } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(Scheduler).toHaveYielded(['A', 'B']); // Hydrate the tree. Child will throw during hydration, but not when it // falls back to client rendering. isClient = true; ReactDOMClient.hydrateRoot(container, , { onRecoverableError(error) { Scheduler.unstable_yieldValue( 'Logged recoverable error: ' + error.message, ); }, }); expect(Scheduler).toFlushAndYield([ 'A', 'B', 'Logged recoverable error: Hydration error', 'Logged recoverable error: There was an error while hydrating this ' + 'Suspense boundary. Switched to client rendering.', 'Logged recoverable error: Hydration error', 'Logged recoverable error: There was an error while hydrating this ' + 'Suspense boundary. Switched to client rendering.', ]); }); // @gate enableServerContext && experimental it('supports ServerContext', async () => { let ServerContext; function inlineLazyServerContextInitialization() { if (!ServerContext) { ServerContext = React.createServerContext('ServerContext', 'default'); } return ServerContext; } function Foo() { inlineLazyServerContextInitialization(); return ( <> ); } function Bar() { const context = React.useContext(inlineLazyServerContextInitialization()); return {context}; } await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(); pipe(writable); }); expect(getVisibleChildren(container)).toEqual([ hi this is server, hi this is server2, hi this is server outer, hi this is server outer2, default, ]); }); // @gate experimental it('Supports iterable', async () => { const Immutable = require('immutable'); const mappedJSX = Immutable.fromJS([ {name: 'a', value: 'a'}, {name: 'b', value: 'b'}, ]).map(item =>
  • {item.get('name')}
  • ); await act(async () => { const {pipe} = ReactDOMFizzServer.renderToPipeableStream(
      {mappedJSX}
    , ); pipe(writable); }); expect(getVisibleChildren(container)).toEqual(
    • a
    • b
    , ); }); describe('error escaping', () => { //@gate experimental it('escapes error hash, message, and component stack values in directly flushed errors (html escaping)', async () => { window.__outlet = {}; const dangerousErrorString = '">