Add support for async toWarnDev scope

Author: eps1lon

Diff for: src/__tests__/render.js

@@ -162,8 +162,8 @@ test('hydrate can have a wrapper', async () => {
   expect(wrapperComponentMountEffect).toHaveBeenCalledTimes(1)
 })
 
-test('legacyRoot uses legacy ReactDOM.render', () => {
-  expect(async () => {
+test('legacyRoot uses legacy ReactDOM.render', async () => {
+  await expect(async () => {
     await render(<div />, {legacyRoot: true})
   }).toErrorDev(
     [
@@ -173,11 +173,11 @@ test('legacyRoot uses legacy ReactDOM.render', () => {
   )
 })
 
-test('legacyRoot uses legacy ReactDOM.hydrate', () => {
+test('legacyRoot uses legacy ReactDOM.hydrate', async () => {
   const ui = <div />
   const container = document.createElement('div')
   container.innerHTML = ReactDOMServer.renderToString(ui)
-  expect(async () => {
+  await expect(async () => {
     await render(ui, {container, hydrate: true, legacyRoot: true})
   }).toErrorDev(
     [

Diff for: src/__tests__/renderHook.js

@@ -65,13 +65,13 @@ test('allows wrapper components', async () => {
   expect(result.current).toEqual('provided')
 })
 
-test('legacyRoot uses legacy ReactDOM.render', () => {
+test('legacyRoot uses legacy ReactDOM.render', async () => {
   const Context = React.createContext('default')
   function Wrapper({children}) {
     return <Context.Provider value="provided">{children}</Context.Provider>
   }
   let result
-  expect(async () => {
+  await expect(async () => {
     result = (
       await renderHook(
         () => {

Diff for: tests/toWarnDev.js

@@ -181,11 +181,7 @@ const createMatcherFor = (consoleMethod, matcherName) =>
       // Avoid using Jest's built-in spy since it can't be removed.
       console[consoleMethod] = consoleSpy
 
-      try {
-        callback()
-      } catch (error) {
-        caughtError = error
-      } finally {
+      const onFinally = () => {
         // Restore the unspied method so that unexpected errors fail tests.
         console[consoleMethod] = originalMethod
 
@@ -289,11 +285,56 @@ const createMatcherFor = (consoleMethod, matcherName) =>
 
         return {pass: true}
       }
+
+      let returnPromise = null
+      try {
+        const result = callback()
+
+        if (
+          typeof result === 'object' &&
+          result !== null &&
+          typeof result.then === 'function'
+        ) {
+          // `act` returns a thenable that can't be chained.
+          // Once `act(async () => {}).then(() => {}).then(() => {})` works
+          // we can just return `result.then(onFinally, error => ...)`
+          returnPromise = new Promise((resolve, reject) => {
+            result
+              .then(
+                () => {
+                  resolve(onFinally())
+                },
+                error => {
+                  caughtError = error
+                  return resolve(onFinally())
+                },
+              )
+              // In case onFinally throws we need to reject from this matcher
+              .catch(error => {
+                reject(error)
+              })
+          })
+        }
+      } catch (error) {
+        caughtError = error
+      } finally {
+        return returnPromise === null ? onFinally() : returnPromise
+      }
     } else {
       // Any uncaught errors or warnings should fail tests in production mode.
-      callback()
+      const result = callback()
 
-      return {pass: true}
+      if (
+        typeof result === 'object' &&
+        result !== null &&
+        typeof result.then === 'function'
+      ) {
+        return result.then(() => {
+          return {pass: true}
+        })
+      } else {
+        return {pass: true}
+      }
     }
   }