expeditaea 1.0.0

package/test/dev/modern.client.test.js

@@ -0,0 +1,53 @@
+import { loadFixture, getPort, Nuxt, rp } from '../utils'
+
+let nuxt, port
+const url = route => 'http://localhost:' + port + route
+
+describe('modern client mode (SSR)', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('modern', { modern: 'client' })
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('should contain nomodule legacy resources', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('script nomodule crossorigin="use-credentials" src="/_nuxt/app.js')
+    expect(response).toContain('script nomodule crossorigin="use-credentials" src="/_nuxt/commons/app.js')
+  })
+
+  test('should contain module modern resources', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('<script type="module" crossorigin="use-credentials" src="/_nuxt/app.modern.js"')
+    expect(response).toContain('<script type="module" crossorigin="use-credentials" src="/_nuxt/commons/app.modern.js"')
+  })
+
+  test('should contain module preload resources', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('<link rel="modulepreload" crossorigin="use-credentials" href="/_nuxt/app.modern.js" as="script">')
+    expect(response).toContain('<link rel="modulepreload" crossorigin="use-credentials" href="/_nuxt/commons/app.modern.js" as="script">')
+  })
+
+  test('should contain module http2 pushed resources', async () => {
+    const { headers: { link } } = await rp(url('/'))
+    expect(link).toEqual([
+      '</_nuxt/runtime.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script',
+      '</_nuxt/commons/app.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script',
+      '</_nuxt/app.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script',
+      `</_nuxt/pages/index.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script`
+    ].join(', '))
+  })
+
+  test('should contain safari fix script', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('"noModule"')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/modern.server.test.js

@@ -0,0 +1,79 @@
+import consola from 'consola'
+import { loadFixture, getPort, Nuxt, rp, wChunk } from '../utils'
+
+let nuxt, port
+const url = route => 'http://localhost:' + port + route
+const modernUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36'
+const modernInfo = mode => `Modern bundles are detected. Modern mode (\`${mode}\`) is enabled now.`
+
+describe('modern server mode', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('modern')
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('should detect server modern mode', async () => {
+    await nuxt.server.renderAndGetWindow(url('/'))
+    expect(consola.info).toHaveBeenCalledWith(modernInfo('server'))
+  })
+
+  test('should use legacy resources by default', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('/_nuxt/app.js')
+    expect(response).toContain('/_nuxt/commons/app.js')
+  })
+
+  test('should use modern resources for modern resources', async () => {
+    const { body: response } = await rp(url('/'), { headers: { 'user-agent': modernUA } })
+    expect(response).toContain('/_nuxt/app.modern.js')
+    expect(response).toContain('/_nuxt/commons/app.modern.js')
+  })
+
+  test('should include es6 syntax in modern resources', async () => {
+    const { body: response } = await rp(url(`/_nuxt/pages/index.modern.js`))
+    expect(response).toContain('=>')
+  })
+
+  test('should not include es6 syntax in normal resources', async () => {
+    const { body: response } = await rp(url(`/_nuxt/pages/index.js`))
+    expect(response).not.toContain('=>')
+  })
+
+  test('should contain legacy http2 pushed resources', async () => {
+    const { headers: { link } } = await rp(url('/'))
+    expect(link).toEqual([
+      '</_nuxt/runtime.js>; rel=preload; crossorigin=use-credentials; as=script',
+      '</_nuxt/commons/app.js>; rel=preload; crossorigin=use-credentials; as=script',
+      '</_nuxt/app.js>; rel=preload; crossorigin=use-credentials; as=script',
+      `</_nuxt/${wChunk('pages/index.js')}>; rel=preload; crossorigin=use-credentials; as=script`
+    ].join(', '))
+  })
+
+  test('should contain module http2 pushed resources', async () => {
+    const { headers: { link } } = await rp(url('/'), {
+      headers: { 'user-agent': modernUA }
+    })
+    expect(link).toEqual([
+      '</_nuxt/runtime.modern.js>; rel=preload; crossorigin=use-credentials; as=script',
+      '</_nuxt/commons/app.modern.js>; rel=preload; crossorigin=use-credentials; as=script',
+      '</_nuxt/app.modern.js>; rel=preload; crossorigin=use-credentials; as=script',
+      `</_nuxt/pages/index.modern.js>; rel=preload; crossorigin=use-credentials; as=script`
+    ].join(', '))
+  })
+
+  test('Vary header should contain User-Agent', async () => {
+    const { headers: { vary } } = await rp(url('/'), {
+      headers: { 'user-agent': modernUA }
+    })
+    expect(vary).toContain('User-Agent')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/modern.spa.test.js

@@ -0,0 +1,75 @@
+import consola from 'consola'
+import { loadFixture, getPort, Nuxt, rp } from '../utils'
+
+let nuxt, port, options
+const url = route => 'http://localhost:' + port + route
+const modernUA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36'
+const modernInfo = mode => `Modern bundles are detected. Modern mode (\`${mode}\`) is enabled now.`
+
+describe('modern client mode (SPA)', () => {
+  beforeAll(async () => {
+    options = await loadFixture('modern', { render: { ssr: false } })
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('should detect client modern mode', async () => {
+    await nuxt.server.renderAndGetWindow(url('/'))
+    expect(consola.info).toHaveBeenCalledWith(modernInfo('client'))
+  })
+
+  test('should contain nomodule legacy resources', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('src="/_nuxt/app.js" crossorigin="use-credentials" nomodule')
+    expect(response).toContain('src="/_nuxt/commons/app.js" crossorigin="use-credentials" nomodule')
+  })
+
+  test('should contain module modern resources', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('<script src="/_nuxt/app.modern.js" type="module" crossorigin="use-credentials"')
+    expect(response).toContain('<script src="/_nuxt/commons/app.modern.js" type="module" crossorigin="use-credentials"')
+  })
+
+  test('should contain legacy preload resources', async () => {
+    const { body: response } = await rp(url('/'))
+    expect(response).toContain('<link rel="preload" crossorigin="use-credentials" href="/_nuxt/app.js" as="script">')
+    expect(response).toContain('<link rel="preload" crossorigin="use-credentials" href="/_nuxt/commons/app.js" as="script">')
+  })
+
+  test('should contain legacy http2 pushed resources', async () => {
+    const { headers: { link } } = await rp(url('/'))
+    expect(link).toEqual([
+      '</_nuxt/runtime.js>; rel=preload; crossorigin=use-credentials; as=script',
+      '</_nuxt/commons/app.js>; rel=preload; crossorigin=use-credentials; as=script',
+      '</_nuxt/app.js>; rel=preload; crossorigin=use-credentials; as=script'
+    ].join(', '))
+  })
+
+  test('should contain modern preload resources', async () => {
+    const { body: response } = await rp(url('/'), { headers: { 'user-agent': modernUA } })
+    expect(response).toContain('<link rel="modulepreload" crossorigin="use-credentials" href="/_nuxt/app.modern.js" as="script">')
+    expect(response).toContain('<link rel="modulepreload" crossorigin="use-credentials" href="/_nuxt/commons/app.modern.js" as="script">')
+  })
+
+  test('should contain safari nomodule fix', async () => {
+    const { body: response } = await rp(url('/'), { headers: { 'user-agent': modernUA } })
+    expect(response).toContain('src="/_nuxt/safari-nomodule-fix.js" crossorigin="use-credentials"')
+  })
+
+  test('should contain modern http2 pushed resources', async () => {
+    const { headers: { link } } = await rp(url('/'), { headers: { 'user-agent': modernUA } })
+    expect(link).toEqual([
+      '</_nuxt/runtime.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script',
+      '</_nuxt/commons/app.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script',
+      '</_nuxt/app.modern.js>; rel=modulepreload; crossorigin=use-credentials; as=script'
+    ].join(', '))
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/module.test.js

@@ -0,0 +1,97 @@
+import { normalize, resolve } from 'path'
+import consola from 'consola'
+import { loadFixture, getPort, Nuxt, Builder, rp } from '../utils'
+
+let port
+const url = route => 'http://localhost:' + port + route
+const rootDir = resolve(__dirname, '..', 'fixtures/module')
+
+let nuxt = null
+// let buildSpies = null
+
+describe('module', () => {
+  beforeAll(async () => {
+    const config = await loadFixture('module')
+    nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('Plugin', async () => {
+    expect(normalize(nuxt.options.plugins[0].src).includes(
+      normalize('fixtures/module/.nuxt/basic.reverse.')
+    )).toBe(true)
+    const { html } = await nuxt.server.renderRoute('/')
+    expect(html).toContain('<h1>TXUN</h1>')
+  })
+
+  test('Layout - layouts from Module.addLayout take precedence', async () => {
+    expect(nuxt.options.layouts.layout).toContain('layout')
+
+    const { html } = await nuxt.server.renderRoute('/layout')
+    expect(html).toContain('<h1>Module Layouts</h1>')
+  })
+
+  test('/404 should display the module error layout', async () => {
+    const { html } = await nuxt.server.renderRoute('/404')
+    expect(html).toContain('You should see the error in a different Vue!')
+  })
+
+  test('Hooks', () => {
+    expect(nuxt.__module_hook).toBe(1)
+    expect(nuxt.__renderer_hook).toBe(2)
+  })
+
+  test('Hooks - Functional', () => {
+    expect(nuxt.__ready_called__).toBe(true)
+  })
+
+  // test('Hooks - Error', async () => {
+  //   expect(buildSpies.error.calledWithMatch(/build:extendRoutes/)).toBe(true)
+  // })
+
+  test('Middleware', async () => {
+    const { body: response } = await rp(url('/api'))
+    expect(response).toBe('It works!')
+  })
+
+  test('serverMiddleware with path', async () => {
+    const { body: response } = await rp(url('/midd3'))
+    expect(response).toBe('Be creative when writing test strings! Hey Mama :wave:')
+  })
+
+  test('Hooks - Use external middleware before render', async () => {
+    const { body: response } = await rp(url('/use-middleware'))
+    expect(response).toBe('Use external middleware')
+  })
+
+  test('Hooks - render context', async () => {
+    await nuxt.server.renderRoute('/render-context')
+    expect(nuxt.__render_context).toBeTruthy()
+  })
+
+  test('AddVendor - deprecated', () => {
+    nuxt.moduleContainer.addVendor('nuxt-test')
+    expect(consola.warn).toHaveBeenCalledWith('addVendor has been deprecated due to webpack4 optimization')
+  })
+
+  test('AddLayout - duplicate layout', () => {
+    nuxt.moduleContainer.addLayout(resolve(rootDir, 'modules', 'basic', 'layout.vue'))
+    expect(consola.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Duplicate layout registration, "layout" has been registered as "./basic.layout.')
+    )
+  })
+
+  test('Lodash - deprecated', async () => {
+    const builder = new Builder(nuxt)
+    await builder.generateRoutesAndFiles()
+    expect(consola.warn).toHaveBeenCalledWith('Avoid using _ inside templates')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/named-views.test.js

@@ -0,0 +1,43 @@
+import { getPort, loadFixture, Nuxt } from '../utils'
+
+let port
+let nuxt = null
+
+describe('named views', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('named-views')
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, '0.0.0.0')
+  })
+
+  test('/ - no child, no named', async () => {
+    const { html } = await nuxt.server.renderRoute('/')
+    expect(html).toContain('LEFT:<!---->:LEFT')
+    expect(html).toContain('CHILD:<!---->:CHILD')
+    expect(html).toContain('TOP:<!---->:TOP')
+  })
+
+  test('/section - have child, no named', async () => {
+    const { html } = await nuxt.server.renderRoute('/section')
+    expect(html).toContain('LEFT:<!---->:LEFT')
+    expect(html).toMatch(/CHILD:<div( data-v-.+)*>This page does not have left panel.<\/div>:CHILD/)
+    expect(html).toContain('TOP:<!---->:TOP')
+  })
+
+  test('/child/123 - have child, have named', async () => {
+    const { html } = await nuxt.server.renderRoute('/child/123')
+    expect(html).toMatch(/LEFT:<div( data-v-.+)*>Child Left content!<\/div>:LEFT/)
+    expect(html).toMatch(/CHILD:<div( data-v-.+)*>Child content ID:123!<\/div>:CHILD/)
+    expect(html).toContain('TOP:<!---->:TOP')
+  })
+
+  test('/main - no child, no named left, have named top', async () => {
+    const { html } = await nuxt.server.renderRoute('/main')
+    expect(html).toMatch(/TOP:<div( data-v-.+)*>Main Top content!<\/div>:TOP/)
+    expect(html).toContain('LEFT:<!---->:LEFT')
+    expect(html).toContain('CHILD:<!---->:CHILD')
+  })
+})

package/test/dev/nuxt.test.js

@@ -0,0 +1,66 @@
+import { resolve } from 'path'
+import { loadFixture, getPort, Nuxt, Builder } from '../utils'
+
+describe('nuxt', () => {
+  test('Nuxt Class', () => {
+    expect(typeof Nuxt).toBe('function')
+  })
+
+  test('Nuxt Instance', async () => {
+    const config = await loadFixture('empty')
+    const nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    expect(typeof nuxt).toBe('object')
+    expect(nuxt.options.dev).toBe(false)
+    expect(typeof nuxt._ready.then).toBe('function')
+    expect(nuxt._initCalled).toBe(true)
+  })
+
+  test('Fail to build when no pages/ directory but is in the parent', async () => {
+    const config = await loadFixture('empty')
+    const nuxt = new Nuxt({
+      ...config,
+      rootDir: resolve(__dirname, '..', 'fixtures', 'empty', 'pages')
+    })
+
+    try {
+      await new Builder(nuxt).build()
+    } catch (err) {
+      expect(err.message).toContain('No `pages` directory found')
+      expect(err.message).toContain('Did you mean to run `nuxt` in the parent (`../`) directory?')
+    }
+    expect.hasAssertions()
+  })
+
+  test('Build with default page when no pages/ directory', async () => {
+    const config = await loadFixture('missing-pages-dir')
+    const nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    const port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+
+    const { html } = await nuxt.server.renderRoute('/')
+    expect(html).toContain('<h2 class="Landscape__Title">')
+    expect(/Landscape__Page__Explanation/.test(html)).toBe(true)
+
+    await nuxt.close()
+  })
+
+  test('Fail to build when specified plugin isn\'t found', async () => {
+    const config = await loadFixture('missing-plugin')
+    const nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    await expect(new Builder(nuxt).build()).rejects.toThrow('Plugin not found')
+  })
+
+  test('Warn when styleResource isn\'t found', async () => {
+    const config = await loadFixture('missing-style-resource')
+    const nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    await expect(new Builder(nuxt).build()).rejects.toThrow('Style Resource not found')
+  })
+})

package/test/dev/renderer.test.js

@@ -0,0 +1,51 @@
+import consola from 'consola'
+import { MODES } from '@nuxt/utils'
+import { Nuxt } from '../utils'
+
+const NO_BUILD_MSG = /Use either `nuxt build` or `builder\.build\(\)` or start nuxt in development mode/
+const NO_MODERN_BUILD_MSG = /Use either `nuxt build --modern` or `modern` option to build modern files/
+
+describe('renderer', () => {
+  afterEach(() => {
+    consola.fatal.mockClear()
+  })
+
+  test('detect no-build (Universal)', async () => {
+    const nuxt = new Nuxt({
+      _start: true,
+      mode: MODES.universal,
+      dev: false,
+      buildDir: '/path/to/404'
+    })
+
+    await expect(nuxt.ready()).rejects.toThrow(expect.objectContaining({
+      message: expect.stringMatching(NO_BUILD_MSG)
+    }))
+  })
+
+  test('detect no-build (SPA)', async () => {
+    const nuxt = new Nuxt({
+      _start: true,
+      mode: MODES.spa,
+      dev: false,
+      buildDir: '/path/to/404'
+    })
+
+    await expect(nuxt.ready()).rejects.toThrow(expect.objectContaining({
+      message: expect.stringMatching(NO_BUILD_MSG)
+    }))
+  })
+  test('detect no-modern-build', async () => {
+    const nuxt = new Nuxt({
+      _start: true,
+      mode: MODES.universal,
+      modern: 'client',
+      dev: false,
+      buildDir: '/path/to/404'
+    })
+
+    await expect(nuxt.ready()).rejects.toThrow(expect.objectContaining({
+      message: expect.stringMatching(NO_MODERN_BUILD_MSG)
+    }))
+  })
+})

package/test/dev/route-name-splitter.test.js

@@ -0,0 +1,20 @@
+import { resolve } from 'path'
+import fs from 'fs'
+import { promisify } from 'util'
+
+const readFile = promisify(fs.readFile)
+
+describe('route-name-splitter', () => {
+  test('Check routes names', async () => {
+    const routesFile = await readFile(resolve(__dirname, '..', 'fixtures/route-name-splitter/.nuxt/routes.json'), 'utf-8')
+    const routes = JSON.parse(routesFile)
+    expect(routes[0].name).toBe('parent')
+    expect(routes[1].name).toBe('posts')
+    expect(routes[1].children[0].name).toBe('posts/id')
+    expect(routes[2].name).toBe('parent/child')
+    expect(routes[3].name).toBe('index')
+    expect(routes[4].name).toBe('all/p/all')
+    expect(routes[5].name).toBe('all/all')
+    expect(routes[6].name).toBe('all')
+  })
+})

package/test/dev/runtime-config.test.js

@@ -0,0 +1,45 @@
+import { loadFixture, getPort, Nuxt } from '../utils'
+
+let port
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+
+describe('basic ssr', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('runtime-config')
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, '0.0.0.0')
+  })
+
+  test('SSR payload', async () => {
+    const window = await nuxt.server.renderAndGetWindow(url('/'))
+    const payload = window.__NUXT__
+
+    expect(payload.config).toMatchObject({
+      baseURL: '/api'
+    })
+
+    expect(payload.data[0].serverConfig).toMatchObject({
+      baseURL: 'https://google.com/api',
+      API_SECRET: 1234
+    })
+  })
+
+  test('SPA payload ', async () => {
+    const window = await nuxt.server.renderAndGetWindow(url('/?spa'))
+    const payload = window.__NUXT__
+
+    expect(payload.config).toMatchObject({
+      baseURL: '/api'
+    })
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/server.listen.test.js

@@ -0,0 +1,79 @@
+import consola from 'consola'
+
+import { loadFixture, getPort, Nuxt } from '../utils'
+
+let config
+
+describe('server listen', () => {
+  beforeAll(async () => {
+    config = await loadFixture('empty')
+  })
+
+  test('should throw error when listening on same port (prod)', async () => {
+    const nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    const port = await getPort()
+    const listen = () => nuxt.server.listen(port, 'localhost')
+
+    // Listen for first time
+    await listen()
+    expect(nuxt.server.listeners[0].port).toBe(port)
+
+    // Listen for second time
+    await expect(listen()).rejects.toThrow(`Address \`localhost:${port}\` is already in use.`)
+
+    await nuxt.close()
+  })
+
+  test('should assign a random port when listening on same port (dev)', async () => {
+    const nuxt = new Nuxt({ ...config, dev: true })
+    await nuxt.ready()
+
+    const port = await getPort()
+    const listen = () => nuxt.server.listen(port, 'localhost')
+
+    // Listen for first time
+    await listen()
+    expect(nuxt.server.listeners[0].port).toBe(port)
+
+    // Listen for second time
+    await listen()
+    expect(nuxt.server.listeners[1].port).not.toBe(nuxt.server.listeners[0].port)
+    expect(consola.warn).toHaveBeenCalledTimes(1)
+    expect(consola.warn).toHaveBeenCalledWith(`Address \`localhost:${port}\` is already in use.`)
+
+    await nuxt.close()
+  })
+
+  test('should skip the use of default port when listening on port 0', async () => {
+    // Stub process.env.PORT
+    const stubDetails = {
+      originalValue: process.env.PORT,
+      hasProperty: 'PORT' in process.env
+    }
+    const DEFAULT_PORT = '2999'
+    process.env.PORT = DEFAULT_PORT
+
+    // Setup test
+    const nuxt = new Nuxt({ ...config, dev: true })
+    await nuxt.ready()
+
+    const listen = () => nuxt.server.listen(0, 'localhost') // Use port 0 to let allow host to randomly assign a free PORT
+    const toString = (x = '') => `${x}`
+
+    // Nuxt server should not be listening on the DEFAULT_PORT
+    await listen()
+    expect(toString(nuxt.server.listeners[0].port)).not.toBe(DEFAULT_PORT)
+
+    // Reset stub for process.env.PORT
+    if (stubDetails.hasProperty) {
+      process.env.PORT = stubDetails.originalValue
+    } else {
+      delete process.env.PORT
+    }
+
+    // Finalize test
+    await nuxt.close()
+  })
+})

package/test/dev/sockets.test.js

@@ -0,0 +1,16 @@
+import { loadFixture, Nuxt } from '../utils'
+
+describe.posix('basic sockets', () => {
+  test('/', async () => {
+    const options = await loadFixture('sockets')
+    const nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    await nuxt.server.listen()
+
+    const { html } = await nuxt.server.renderRoute('/')
+    expect(html).toContain('<h1>Served over sockets!</h1>')
+
+    await nuxt.close()
+  })
+})