react-code-dataset / next.js /test /development /basic /hmr /run-error-recovery-hmr-test.util.ts

Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

22.7 kB

import { join } from 'path'
import {
  assertHasRedbox,
  assertNoRedbox,
  getBrowserBodyText,
  getRedboxHeader,
  getRedboxDescription,
  getRedboxSource,
  retry,
  waitFor,
  trimEndMultiline,
} from 'next-test-utils'
import { nextTestSetup } from 'e2e-utils'
import { outdent } from 'outdent'

export function runErrorRecoveryHmrTest(nextConfig: {
  basePath: string
  assetPrefix: string
}) {
  const { next } = nextTestSetup({
    files: __dirname,
    nextConfig,
    patchFileDelay: 500,
  })
  const { basePath } = nextConfig

  it('should recover from 404 after a page has been added', async () => {
    const newPage = join('pages', 'hmr', 'new-page.js')

    try {
      const browser = await next.browser(basePath + '/hmr/new-page')

      expect(await browser.elementByCss('body').text()).toMatch(
        /This page could not be found/
      )

      // Add the page
      await next.patchFile(
        newPage,
        'export default () => (<div id="new-page">the-new-page</div>)'
      )

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(/the-new-page/)
      })

      await next.deleteFile(newPage)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This page could not be found/
        )
      })

      expect(next.cliOutput).toContain('Compiled /_error')
    } catch (err) {
      await next.deleteFile(newPage)
      throw err
    }
  })

  it('should recover from 404 after a page has been added with dynamic segments', async () => {
    const newPage = join('pages', 'hmr', '[foo]', 'page.js')

    try {
      const browser = await next.browser(basePath + '/hmr/foo/page')

      expect(await browser.elementByCss('body').text()).toMatch(
        /This page could not be found/
      )

      // Add the page
      await next.patchFile(
        newPage,
        'export default () => (<div id="new-page">the-new-page</div>)'
      )

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(/the-new-page/)
      })

      await next.deleteFile(newPage)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This page could not be found/
        )
      })

      expect(next.cliOutput).toContain('Compiled /_error')
    } catch (err) {
      await next.deleteFile(newPage)
      throw err
    }
  })
  ;(process.env.IS_TURBOPACK_TEST ? it.skip : it)(
    // this test fails frequently with turbopack
    'should not continously poll a custom error page',
    async () => {
      const errorPage = join('pages', '_error.js')

      await next.patchFile(
        errorPage,
        outdent`
          function Error({ statusCode, message, count }) {
            return (
              <div>
                Error Message: {message}
              </div>
            )
          }
          Error.getInitialProps = async ({ res, err }) => {
            const statusCode = res ? res.statusCode : err ? err.statusCode : 404
            console.log('getInitialProps called');
            return {
              statusCode,
              message: err ? err.message : 'Oops...',
            }
          }
          export default Error
        `
      )

      try {
        // navigate to a 404 page
        await next.browser(basePath + '/does-not-exist')

        await retry(() => {
          // eslint-disable-next-line jest/no-standalone-expect
          expect(next.cliOutput).toMatch(/getInitialProps called/)
        })

        const outputIndex = next.cliOutput.length

        // wait a few seconds to ensure polling didn't happen
        await waitFor(3000)

        const logOccurrences =
          next.cliOutput.slice(outputIndex).split('getInitialProps called')
            .length - 1
        // eslint-disable-next-line jest/no-standalone-expect
        expect(logOccurrences).toBe(0)
      } finally {
        await next.deleteFile(errorPage)
      }
    }
  )

  it('should detect syntax errors and recover', async () => {
    const browser = await next.browser(basePath + '/hmr/about2')
    const aboutPage = join('pages', 'hmr', 'about2.js')
    const aboutContent = await next.readFile(aboutPage)
    await retry(async () => {
      expect(await getBrowserBodyText(browser)).toMatch(
        /This is the about page/
      )
    })

    await next.patchFile(aboutPage, aboutContent.replace('</div>', 'div'))

    await assertHasRedbox(browser)
    const source = next.normalizeTestDirContent(await getRedboxSource(browser))

    if (process.env.IS_TURBOPACK_TEST) {
      expect(source).toMatchInlineSnapshot(`
       "./pages/hmr/about2.js (7:1)
       Parsing ecmascript source code failed
         5 |     div
         6 |   )
       > 7 | }
           | ^
         8 |
       Unexpected token. Did you mean \`{'}'}\` or \`&rbrace;\`?"
      `)
    } else if (process.env.NEXT_RSPACK) {
      expect(trimEndMultiline(source)).toMatchInlineSnapshot(`
       "./pages/hmr/about2.js
         × Module build failed:
         ╰─▶   × Error:   x Unexpected token. Did you mean \`{'}'}\` or \`&rbrace;\`?
               │    ,-[7:1]
               │  4 |       <p>This is the about page.</p>
               │  5 |     div
               │  6 |   )
               │  7 | }
               │    : ^
               │    \`----
               │   x Unexpected eof
               │    ,-[7:3]
               │  5 |     div
               │  6 |   )
               │  7 | }
               │    \`----
               │
               │
               │ Caused by:
               │     Syntax Error
       Import trace for requested module:
       ./pages/hmr/about2.js"
      `)
    } else {
      expect(source).toMatchInlineSnapshot(`
          "./pages/hmr/about2.js
          Error:   x Unexpected token. Did you mean \`{'}'}\` or \`&rbrace;\`?
             ,-[7:1]
           4 |       <p>This is the about page.</p>
           5 |     div
           6 |   )
           7 | }
             : ^
             \`----
            x Unexpected eof
             ,-[7:3]
           5 |     div
           6 |   )
           7 | }
             \`----
          Caused by:
              Syntax Error
          Import trace for requested module:
          ./pages/hmr/about2.js"
        `)
    }

    await next.patchFile(aboutPage, aboutContent)

    await retry(async () => {
      expect(await getBrowserBodyText(browser)).toMatch(
        /This is the about page/
      )
    })
  })

  if (!process.env.IS_TURBOPACK_TEST) {
    // Turbopack doesn't have this restriction
    it('should show the error on all pages', async () => {
      const aboutPage = join('pages', 'hmr', 'about2.js')
      const aboutContent = await next.readFile(aboutPage)
      const browser = await next.browser(basePath + '/hmr/contact')
      try {
        await next.render(basePath + '/hmr/about2')

        await next.patchFile(aboutPage, aboutContent.replace('</div>', 'div'))

        // Ensure dev server has time to break:
        await new Promise((resolve) => setTimeout(resolve, 2000))

        await assertHasRedbox(browser)
        expect(await getRedboxSource(browser)).toMatch(/Unexpected eof/)

        await next.patchFile(aboutPage, aboutContent)

        await retry(async () => {
          expect(await getBrowserBodyText(browser)).toMatch(
            /This is the contact page/
          )
        })
      } catch (err) {
        await next.patchFile(aboutPage, aboutContent)
        if (browser) {
          await retry(async () => {
            expect(await getBrowserBodyText(browser)).toMatch(
              /This is the contact page/
            )
          })
        }

        throw err
      }
    })
  }

  it('should detect runtime errors on the module scope', async () => {
    const browser = await next.browser(basePath + '/hmr/about3')
    const aboutPage = join('pages', 'hmr', 'about3.js')
    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace('export', 'aa=20;\nexport')
      )

      await assertHasRedbox(browser)
      expect(await getRedboxHeader(browser)).toMatch(/aa is not defined/)

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
    } finally {
      await next.patchFile(aboutPage, aboutContent)
    }
  })

  it('should recover from errors in the render function', async () => {
    const browser = await next.browser(basePath + '/hmr/about4')
    const aboutPage = join('pages', 'hmr', 'about4.js')
    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace(
          'return',
          'throw new Error("an-expected-error");\nreturn'
        )
      )

      await assertHasRedbox(browser)
      expect(await getRedboxSource(browser)).toMatch(/an-expected-error/)

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
    } catch (err) {
      await next.patchFile(aboutPage, aboutContent)
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      throw err
    }
  })

  it('should recover after exporting an invalid page', async () => {
    const browser = await next.browser(basePath + '/hmr/about5')
    const aboutPage = join('pages', 'hmr', 'about5.js')
    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace(
          'export default',
          'export default {};\nexport const fn ='
        )
      )

      await assertHasRedbox(browser)
      expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
        `"The default export is not a React Component in page: "/hmr/about5""`
      )

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
    } catch (err) {
      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      throw err
    }
  })

  it('should recover after a bad return from the render function', async () => {
    const browser = await next.browser(basePath + '/hmr/about6')
    const aboutPage = join('pages', 'hmr', 'about6.js')
    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace(
          'export default',
          'export default () => /search/;\nexport const fn ='
        )
      )

      await assertHasRedbox(browser)
      // TODO: Replace this when webpack 5 is the default
      expect(await getRedboxHeader(browser)).toMatch(
        `Objects are not valid as a React child (found: [object RegExp]). If you meant to render a collection of children, use an array instead.`
      )

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
    } catch (err) {
      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      throw err
    }
  })

  it('should recover after undefined exported as default', async () => {
    const browser = await next.browser(basePath + '/hmr/about7')
    const aboutPage = join('pages', 'hmr', 'about7.js')

    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace(
          'export default',
          'export default undefined;\nexport const fn ='
        )
      )

      await assertHasRedbox(browser)
      expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
        `"The default export is not a React Component in page: "/hmr/about7""`
      )

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
      await assertNoRedbox(browser)
    } catch (err) {
      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      throw err
    }
  })

  it('should recover after webpack parse error in an imported file', async () => {
    const browser = await next.browser(basePath + '/hmr/about8')
    const aboutPage = join('pages', 'hmr', 'about8.js')

    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace(
          'export default',
          'import "../../components/parse-error.xyz"\nexport default'
        )
      )

      await assertHasRedbox(browser)
      expect(await getRedboxHeader(browser)).toMatch('Build Error')

      if (process.env.IS_TURBOPACK_TEST) {
        expect(await getRedboxSource(browser)).toMatchInlineSnapshot(`
              "./components/parse-error.xyz
              Unknown module type
              This module doesn't have an associated type. Use a known file extension, or register a loader for it.
              Read more: https://nextjs.org/docs/app/api-reference/next-config-js/turbo#webpack-loaders"
            `)
      } else if (process.env.NEXT_RSPACK) {
        expect(trimEndMultiline(await getRedboxSource(browser)))
          .toMatchInlineSnapshot(`
         "./components/parse-error.xyz
           × Module parse failed:
           ╰─▶   × JavaScript parse error: Expression expected
                  ╭─[3:0]
                1 │ This
                2 │ is
                3 │ }}}
                  · ─
                4 │ invalid
                5 │ js
                  ╰────
           help:
                 You may need an appropriate loader to handle this file type.
         Import trace for requested module:
         ./components/parse-error.xyz
         ./pages/hmr/about8.js"
        `)
      } else {
        expect(await getRedboxSource(browser)).toMatchInlineSnapshot(`
                      "./components/parse-error.xyz
                      Module parse failed: Unexpected token (3:0)
                      You may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders
                      | This
                      | is
                      > }}}
                      | invalid
                      | js
                      Import trace for requested module:
                      ./components/parse-error.xyz
                      ./pages/hmr/about8.js"
                  `)
      }

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
      await assertNoRedbox(browser)
    } catch (err) {
      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      throw err
    }
  })

  it('should recover after loader parse error in an imported file', async () => {
    const browser = await next.browser(basePath + '/hmr/about9')
    const aboutPage = join('pages', 'hmr', 'about9.js')

    const aboutContent = await next.readFile(aboutPage)
    try {
      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })

      await next.patchFile(
        aboutPage,
        aboutContent.replace(
          'export default',
          'import "../../components/parse-error.js"\nexport default'
        )
      )

      await assertHasRedbox(browser)
      expect(await getRedboxHeader(browser)).toMatch('Build Error')
      let redboxSource = await getRedboxSource(browser)

      redboxSource = redboxSource.replace(`${next.testDir}`, '.')
      if (process.env.IS_TURBOPACK_TEST) {
        expect(next.normalizeTestDirContent(redboxSource))
          .toMatchInlineSnapshot(`
         "./components/parse-error.js (3:1)
         Parsing ecmascript source code failed
           1 | This
           2 | is
         > 3 | }}}
             | ^
           4 | invalid
           5 | js
         Expression expected
         Import traces:
           Browser:
             ./components/parse-error.js
             ./pages/hmr/about9.js
           SSR:
             ./components/parse-error.js
             ./pages/hmr/about9.js"
        `)
      } else if (process.env.NEXT_RSPACK) {
        expect(trimEndMultiline(next.normalizeTestDirContent(redboxSource)))
          .toMatchInlineSnapshot(`
         "./components/parse-error.js
           × Module build failed:
           ╰─▶   × Error:   x Expression expected
                 │    ,-[3:1]
                 │  1 | This
                 │  2 | is
                 │  3 | }}}
                 │    : ^
                 │  4 | invalid
                 │  5 | js
                 │    \`----
                 │
                 │
                 │ Caused by:
                 │     Syntax Error
         Import trace for requested module:
         ./components/parse-error.js
         ./pages/hmr/about9.js"
        `)
      } else {
        redboxSource = redboxSource.substring(0, redboxSource.indexOf('`----'))

        expect(next.normalizeTestDirContent(redboxSource))
          .toMatchInlineSnapshot(`
            "./components/parse-error.js
            Error:   x Expression expected
               ,-[3:1]
             1 | This
             2 | is
             3 | }}}
               : ^
             4 | invalid
             5 | js
               "
          `)
      }

      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
      await assertNoRedbox(browser)
    } catch (err) {
      await next.patchFile(aboutPage, aboutContent)

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(
          /This is the about page/
        )
      })
    }
  })

  it('should recover from errors in getInitialProps in client', async () => {
    const browser = await next.browser(basePath + '/hmr')
    const erroredPage = join('pages', 'hmr', 'error-in-gip.js')
    const errorContent = await next.readFile(erroredPage)
    try {
      await browser.elementByCss('#error-in-gip-link').click()

      await assertHasRedbox(browser)
      expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
        `"an-expected-error-in-gip"`
      )

      await next.patchFile(
        erroredPage,
        errorContent.replace('throw error', 'return {}')
      )

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(/Hello/)
      })

      await next.patchFile(erroredPage, errorContent)

      await retry(async () => {
        await browser.refresh()
        await waitFor(2000)
        const text = await getBrowserBodyText(browser)
        if (text.includes('Hello')) {
          throw new Error('waiting')
        }
        return expect(await getRedboxSource(browser)).toMatch(
          /an-expected-error-in-gip/
        )
      })
    } catch (err) {
      await next.patchFile(erroredPage, errorContent)

      throw err
    }
  })

  it('should recover after an error reported via SSR', async () => {
    const browser = await next.browser(basePath + '/hmr/error-in-gip')
    const erroredPage = join('pages', 'hmr', 'error-in-gip.js')
    const errorContent = await next.readFile(erroredPage)
    try {
      await assertHasRedbox(browser)
      expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
        `"an-expected-error-in-gip"`
      )

      const erroredPage = join('pages', 'hmr', 'error-in-gip.js')

      await next.patchFile(
        erroredPage,
        errorContent.replace('throw error', 'return {}')
      )

      await retry(async () => {
        expect(await getBrowserBodyText(browser)).toMatch(/Hello/)
      })

      await next.patchFile(erroredPage, errorContent)

      await retry(async () => {
        await browser.refresh()
        await waitFor(2000)
        const text = await getBrowserBodyText(browser)
        if (text.includes('Hello')) {
          throw new Error('waiting')
        }
        return expect(await getRedboxSource(browser)).toMatch(
          /an-expected-error-in-gip/
        )
      })
    } catch (err) {
      await next.patchFile(erroredPage, errorContent)

      throw err
    }
  })

  if (!process.env.IS_TURBOPACK_TEST) {
    it('should have client HMR events in trace file', async () => {
      const traceData = await next.readFile('.next/trace')
      expect(traceData).toContain('client-hmr-latency')
      expect(traceData).toContain('client-error')
      expect(traceData).toContain('client-success')
      expect(traceData).toContain('client-full-reload')
    })
  }
}

	import { join } from 'path'
	import {
	assertHasRedbox,
	assertNoRedbox,
	getBrowserBodyText,
	getRedboxHeader,
	getRedboxDescription,
	getRedboxSource,
	retry,
	waitFor,
	trimEndMultiline,
	} from 'next-test-utils'
	import { nextTestSetup } from 'e2e-utils'
	import { outdent } from 'outdent'

	export function runErrorRecoveryHmrTest(nextConfig: {
	basePath: string
	assetPrefix: string
	}) {
	const { next } = nextTestSetup({
	files: __dirname,
	nextConfig,
	patchFileDelay: 500,
	})
	const { basePath } = nextConfig

	it('should recover from 404 after a page has been added', async () => {
	const newPage = join('pages', 'hmr', 'new-page.js')

	try {
	const browser = await next.browser(basePath + '/hmr/new-page')

	expect(await browser.elementByCss('body').text()).toMatch(
	/This page could not be found/
	)

	// Add the page
	await next.patchFile(
	newPage,
	'export default () => (<div id="new-page">the-new-page</div>)'
	)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(/the-new-page/)
	})

	await next.deleteFile(newPage)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This page could not be found/
	)
	})

	expect(next.cliOutput).toContain('Compiled /_error')
	} catch (err) {
	await next.deleteFile(newPage)
	throw err
	}
	})

	it('should recover from 404 after a page has been added with dynamic segments', async () => {
	const newPage = join('pages', 'hmr', '[foo]', 'page.js')

	try {
	const browser = await next.browser(basePath + '/hmr/foo/page')

	expect(await browser.elementByCss('body').text()).toMatch(
	/This page could not be found/
	)

	// Add the page
	await next.patchFile(
	newPage,
	'export default () => (<div id="new-page">the-new-page</div>)'
	)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(/the-new-page/)
	})

	await next.deleteFile(newPage)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This page could not be found/
	)
	})

	expect(next.cliOutput).toContain('Compiled /_error')
	} catch (err) {
	await next.deleteFile(newPage)
	throw err
	}
	})
	;(process.env.IS_TURBOPACK_TEST ? it.skip : it)(
	// this test fails frequently with turbopack
	'should not continously poll a custom error page',
	async () => {
	const errorPage = join('pages', '_error.js')

	await next.patchFile(
	errorPage,
	outdent`
	function Error({ statusCode, message, count }) {
	return (
	<div>
	Error Message: {message}
	</div>
	)
	}

	Error.getInitialProps = async ({ res, err }) => {
	const statusCode = res ? res.statusCode : err ? err.statusCode : 404
	console.log('getInitialProps called');
	return {
	statusCode,
	message: err ? err.message : 'Oops...',
	}
	}

	export default Error
	`
	)

	try {
	// navigate to a 404 page
	await next.browser(basePath + '/does-not-exist')

	await retry(() => {
	// eslint-disable-next-line jest/no-standalone-expect
	expect(next.cliOutput).toMatch(/getInitialProps called/)
	})

	const outputIndex = next.cliOutput.length

	// wait a few seconds to ensure polling didn't happen
	await waitFor(3000)

	const logOccurrences =
	next.cliOutput.slice(outputIndex).split('getInitialProps called')
	.length - 1
	// eslint-disable-next-line jest/no-standalone-expect
	expect(logOccurrences).toBe(0)
	} finally {
	await next.deleteFile(errorPage)
	}
	}
	)

	it('should detect syntax errors and recover', async () => {
	const browser = await next.browser(basePath + '/hmr/about2')
	const aboutPage = join('pages', 'hmr', 'about2.js')
	const aboutContent = await next.readFile(aboutPage)
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(aboutPage, aboutContent.replace('</div>', 'div'))

	await assertHasRedbox(browser)
	const source = next.normalizeTestDirContent(await getRedboxSource(browser))

	if (process.env.IS_TURBOPACK_TEST) {
	expect(source).toMatchInlineSnapshot(`
	"./pages/hmr/about2.js (7:1)
	Parsing ecmascript source code failed
	5 \| div
	6 \| )
	> 7 \| }
	\| ^
	8 \|

	Unexpected token. Did you mean \`{'}'}\` or \`}\`?"
	`)
	} else if (process.env.NEXT_RSPACK) {
	expect(trimEndMultiline(source)).toMatchInlineSnapshot(`
	"./pages/hmr/about2.js
	× Module build failed:
	╰─▶ × Error: x Unexpected token. Did you mean \`{'}'}\` or \`}\`?
	│ ,-[7:1]
	│ 4 \| <p>This is the about page.</p>
	│ 5 \| div
	│ 6 \| )
	│ 7 \| }
	│ : ^
	│ \`----
	│ x Unexpected eof
	│ ,-[7:3]
	│ 5 \| div
	│ 6 \| )
	│ 7 \| }
	│ \`----
	│
	│
	│ Caused by:
	│ Syntax Error

	Import trace for requested module:
	./pages/hmr/about2.js"
	`)
	} else {
	expect(source).toMatchInlineSnapshot(`
	"./pages/hmr/about2.js
	Error: x Unexpected token. Did you mean \`{'}'}\` or \`}\`?
	,-[7:1]
	4 \| <p>This is the about page.</p>
	5 \| div
	6 \| )
	7 \| }
	: ^
	\`----
	x Unexpected eof
	,-[7:3]
	5 \| div
	6 \| )
	7 \| }
	\`----

	Caused by:
	Syntax Error

	Import trace for requested module:
	./pages/hmr/about2.js"
	`)
	}

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	})

	if (!process.env.IS_TURBOPACK_TEST) {
	// Turbopack doesn't have this restriction
	it('should show the error on all pages', async () => {
	const aboutPage = join('pages', 'hmr', 'about2.js')
	const aboutContent = await next.readFile(aboutPage)
	const browser = await next.browser(basePath + '/hmr/contact')
	try {
	await next.render(basePath + '/hmr/about2')

	await next.patchFile(aboutPage, aboutContent.replace('</div>', 'div'))

	// Ensure dev server has time to break:
	await new Promise((resolve) => setTimeout(resolve, 2000))

	await assertHasRedbox(browser)
	expect(await getRedboxSource(browser)).toMatch(/Unexpected eof/)

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the contact page/
	)
	})
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)
	if (browser) {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the contact page/
	)
	})
	}

	throw err
	}
	})
	}

	it('should detect runtime errors on the module scope', async () => {
	const browser = await next.browser(basePath + '/hmr/about3')
	const aboutPage = join('pages', 'hmr', 'about3.js')
	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace('export', 'aa=20;\nexport')
	)

	await assertHasRedbox(browser)
	expect(await getRedboxHeader(browser)).toMatch(/aa is not defined/)

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	} finally {
	await next.patchFile(aboutPage, aboutContent)
	}
	})

	it('should recover from errors in the render function', async () => {
	const browser = await next.browser(basePath + '/hmr/about4')
	const aboutPage = join('pages', 'hmr', 'about4.js')
	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace(
	'return',
	'throw new Error("an-expected-error");\nreturn'
	)
	)

	await assertHasRedbox(browser)
	expect(await getRedboxSource(browser)).toMatch(/an-expected-error/)

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	throw err
	}
	})

	it('should recover after exporting an invalid page', async () => {
	const browser = await next.browser(basePath + '/hmr/about5')
	const aboutPage = join('pages', 'hmr', 'about5.js')
	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace(
	'export default',
	'export default {};\nexport const fn ='
	)
	)

	await assertHasRedbox(browser)
	expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
	`"The default export is not a React Component in page: "/hmr/about5""`
	)

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	throw err
	}
	})

	it('should recover after a bad return from the render function', async () => {
	const browser = await next.browser(basePath + '/hmr/about6')
	const aboutPage = join('pages', 'hmr', 'about6.js')
	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace(
	'export default',
	'export default () => /search/;\nexport const fn ='
	)
	)

	await assertHasRedbox(browser)
	// TODO: Replace this when webpack 5 is the default
	expect(await getRedboxHeader(browser)).toMatch(
	`Objects are not valid as a React child (found: [object RegExp]). If you meant to render a collection of children, use an array instead.`
	)

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	throw err
	}
	})

	it('should recover after undefined exported as default', async () => {
	const browser = await next.browser(basePath + '/hmr/about7')
	const aboutPage = join('pages', 'hmr', 'about7.js')

	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace(
	'export default',
	'export default undefined;\nexport const fn ='
	)
	)

	await assertHasRedbox(browser)
	expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
	`"The default export is not a React Component in page: "/hmr/about7""`
	)

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	await assertNoRedbox(browser)
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	throw err
	}
	})

	it('should recover after webpack parse error in an imported file', async () => {
	const browser = await next.browser(basePath + '/hmr/about8')
	const aboutPage = join('pages', 'hmr', 'about8.js')

	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace(
	'export default',
	'import "../../components/parse-error.xyz"\nexport default'
	)
	)

	await assertHasRedbox(browser)
	expect(await getRedboxHeader(browser)).toMatch('Build Error')

	if (process.env.IS_TURBOPACK_TEST) {
	expect(await getRedboxSource(browser)).toMatchInlineSnapshot(`
	"./components/parse-error.xyz
	Unknown module type
	This module doesn't have an associated type. Use a known file extension, or register a loader for it.

	Read more: https://nextjs.org/docs/app/api-reference/next-config-js/turbo#webpack-loaders"
	`)
	} else if (process.env.NEXT_RSPACK) {
	expect(trimEndMultiline(await getRedboxSource(browser)))
	.toMatchInlineSnapshot(`
	"./components/parse-error.xyz
	× Module parse failed:
	╰─▶ × JavaScript parse error: Expression expected
	╭─[3:0]
	1 │ This
	2 │ is
	3 │ }}}
	· ─
	4 │ invalid
	5 │ js
	╰────

	help:
	You may need an appropriate loader to handle this file type.

	Import trace for requested module:
	./components/parse-error.xyz
	./pages/hmr/about8.js"
	`)
	} else {
	expect(await getRedboxSource(browser)).toMatchInlineSnapshot(`
	"./components/parse-error.xyz
	Module parse failed: Unexpected token (3:0)
	You may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders
	\| This
	\| is
	> }}}
	\| invalid
	\| js

	Import trace for requested module:
	./components/parse-error.xyz
	./pages/hmr/about8.js"
	`)
	}

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	await assertNoRedbox(browser)
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	throw err
	}
	})

	it('should recover after loader parse error in an imported file', async () => {
	const browser = await next.browser(basePath + '/hmr/about9')
	const aboutPage = join('pages', 'hmr', 'about9.js')

	const aboutContent = await next.readFile(aboutPage)
	try {
	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})

	await next.patchFile(
	aboutPage,
	aboutContent.replace(
	'export default',
	'import "../../components/parse-error.js"\nexport default'
	)
	)

	await assertHasRedbox(browser)
	expect(await getRedboxHeader(browser)).toMatch('Build Error')
	let redboxSource = await getRedboxSource(browser)

	redboxSource = redboxSource.replace(`${next.testDir}`, '.')
	if (process.env.IS_TURBOPACK_TEST) {
	expect(next.normalizeTestDirContent(redboxSource))
	.toMatchInlineSnapshot(`
	"./components/parse-error.js (3:1)
	Parsing ecmascript source code failed
	1 \| This
	2 \| is
	> 3 \| }}}
	\| ^
	4 \| invalid
	5 \| js

	Expression expected

	Import traces:
	Browser:
	./components/parse-error.js
	./pages/hmr/about9.js

	SSR:
	./components/parse-error.js
	./pages/hmr/about9.js"
	`)
	} else if (process.env.NEXT_RSPACK) {
	expect(trimEndMultiline(next.normalizeTestDirContent(redboxSource)))
	.toMatchInlineSnapshot(`
	"./components/parse-error.js
	× Module build failed:
	╰─▶ × Error: x Expression expected
	│ ,-[3:1]
	│ 1 \| This
	│ 2 \| is
	│ 3 \| }}}
	│ : ^
	│ 4 \| invalid
	│ 5 \| js
	│ \`----
	│
	│
	│ Caused by:
	│ Syntax Error

	Import trace for requested module:
	./components/parse-error.js
	./pages/hmr/about9.js"
	`)
	} else {
	redboxSource = redboxSource.substring(0, redboxSource.indexOf('`----'))

	expect(next.normalizeTestDirContent(redboxSource))
	.toMatchInlineSnapshot(`
	"./components/parse-error.js
	Error: x Expression expected
	,-[3:1]
	1 \| This
	2 \| is
	3 \| }}}
	: ^
	4 \| invalid
	5 \| js
	"
	`)
	}

	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	await assertNoRedbox(browser)
	} catch (err) {
	await next.patchFile(aboutPage, aboutContent)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(
	/This is the about page/
	)
	})
	}
	})

	it('should recover from errors in getInitialProps in client', async () => {
	const browser = await next.browser(basePath + '/hmr')
	const erroredPage = join('pages', 'hmr', 'error-in-gip.js')
	const errorContent = await next.readFile(erroredPage)
	try {
	await browser.elementByCss('#error-in-gip-link').click()

	await assertHasRedbox(browser)
	expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
	`"an-expected-error-in-gip"`
	)

	await next.patchFile(
	erroredPage,
	errorContent.replace('throw error', 'return {}')
	)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(/Hello/)
	})

	await next.patchFile(erroredPage, errorContent)

	await retry(async () => {
	await browser.refresh()
	await waitFor(2000)
	const text = await getBrowserBodyText(browser)
	if (text.includes('Hello')) {
	throw new Error('waiting')
	}
	return expect(await getRedboxSource(browser)).toMatch(
	/an-expected-error-in-gip/
	)
	})
	} catch (err) {
	await next.patchFile(erroredPage, errorContent)

	throw err
	}
	})

	it('should recover after an error reported via SSR', async () => {
	const browser = await next.browser(basePath + '/hmr/error-in-gip')
	const erroredPage = join('pages', 'hmr', 'error-in-gip.js')
	const errorContent = await next.readFile(erroredPage)
	try {
	await assertHasRedbox(browser)
	expect(await getRedboxDescription(browser)).toMatchInlineSnapshot(
	`"an-expected-error-in-gip"`
	)

	const erroredPage = join('pages', 'hmr', 'error-in-gip.js')

	await next.patchFile(
	erroredPage,
	errorContent.replace('throw error', 'return {}')
	)

	await retry(async () => {
	expect(await getBrowserBodyText(browser)).toMatch(/Hello/)
	})

	await next.patchFile(erroredPage, errorContent)

	await retry(async () => {
	await browser.refresh()
	await waitFor(2000)
	const text = await getBrowserBodyText(browser)
	if (text.includes('Hello')) {
	throw new Error('waiting')
	}
	return expect(await getRedboxSource(browser)).toMatch(
	/an-expected-error-in-gip/
	)
	})
	} catch (err) {
	await next.patchFile(erroredPage, errorContent)

	throw err
	}
	})

	if (!process.env.IS_TURBOPACK_TEST) {
	it('should have client HMR events in trace file', async () => {
	const traceData = await next.readFile('.next/trace')
	expect(traceData).toContain('client-hmr-latency')
	expect(traceData).toContain('client-error')
	expect(traceData).toContain('client-success')
	expect(traceData).toContain('client-full-reload')
	})
	}
	}