expeditaea 1.0.0

package/test/dev/basic.dev.test.js

@@ -0,0 +1,204 @@
+import path from 'path'
+import jsdom from 'jsdom'
+import consola from 'consola'
+import { Builder, BundleBuilder, getPort, loadFixture, Nuxt, rp, waitFor } from '../utils'
+
+let port
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+let builder = null
+let transpile = null
+let output = null
+let loadersOptions
+let vueLoader
+let postcssLoader
+
+describe('basic dev', () => {
+  beforeAll(async () => {
+    const config = await loadFixture('basic', {
+      dev: true,
+      debug: true,
+      buildDir: '.nuxt-dev',
+      build: {
+        filenames: {
+          app: ({ isDev }) => {
+            return isDev ? 'test-app.js' : 'test-app.[contenthash].js'
+          },
+          chunk: 'test-[name].[contenthash].js'
+        },
+        transpile: [
+          '@scoped/packageA',
+          '@scoped\\packageB',
+          'vue.test.js',
+          /vue-test/,
+          ({ isModern }) => isModern ? 'modern-test' : 'normal-test'
+        ],
+        loaders: {
+          cssModules: {
+            modules: {
+              localIdentName: '[hash:base64:6]'
+            }
+          }
+        },
+        extend ({ module: { rules }, output: wpOutput }, { isClient, loaders }) {
+          if (isClient) {
+            const babelLoader = rules.find(loader => loader.test.test('.jsx'))
+            transpile = file => !babelLoader.exclude(file)
+            output = wpOutput
+            loadersOptions = loaders
+            vueLoader = rules.find(loader => loader.test.test('.vue'))
+            const cssLoaders = rules.find(loader => loader.test.test('.css')).oneOf[0].use
+            postcssLoader = cssLoaders[cssLoaders.length - 1]
+          }
+        }
+      },
+      hooks: {
+        'vue-renderer:ssr:context': ({ nuxt }) => {
+          nuxt.logs = [{ type: 'log', args: ['This is a test ssr log'] }]
+        }
+      },
+      render: {
+        ssrLog: 'collapsed'
+      }
+    })
+
+    nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    builder = new Builder(nuxt, BundleBuilder)
+
+    await builder.build()
+    await waitFor(2000) // TODO: Find a better way
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('Check build:done hook called', () => {
+    expect(builder.__hook_built_called__).toBe(true)
+  })
+
+  test('Config: build.transpile', () => {
+    expect(transpile('vue-test')).toBe(true)
+    expect(transpile(path.normalize('node_modules/test.js'))).toBe(false)
+    expect(transpile(path.normalize('node_modules/vue-test'))).toBe(true)
+    expect(transpile(path.normalize('node_modules/vue.test.js'))).toBe(true)
+    expect(transpile(path.normalize('node_modules/test.vue.js'))).toBe(true)
+    expect(transpile(path.normalize('node_modules/@scoped/packageA/src/index.js'))).toBe(true)
+    expect(transpile(path.normalize('node_modules/@scoped/packageB/src/index.js'))).toBe(true)
+    expect(transpile(path.normalize('node_modules/normal-test'))).toBe(true)
+  })
+
+  test('Config: build.filenames', () => {
+    expect(output.filename).toBe('test-app.js')
+    expect(output.chunkFilename).toBe('test-[name].[contenthash].js')
+    expect(consola.warn).toBeCalledWith(
+      'Notice: Please do not use contenthash in dev mode to prevent memory leak'
+    )
+  })
+
+  test('Config: build.loaders', () => {
+    expect(Object.keys(loadersOptions)).toHaveLength(12)
+    expect(loadersOptions).toHaveProperty(
+      'file', 'fontUrl', 'imgUrl', 'pugPlain', 'vue',
+      'css', 'cssModules', 'less', 'sass', 'scss', 'stylus', 'vueStyle'
+    )
+    const { cssModules, vue } = loadersOptions
+    expect(cssModules.modules.localIdentName).toBe('[hash:base64:6]')
+    expect(vueLoader.options).toBe(vue)
+  })
+
+  test('Config: preset-env and cssnano are at then end of postcss plugins', () => {
+    const plugins = postcssLoader.options.plugins.map((plugin) => {
+      return plugin.postcssPlugin
+    })
+    expect(plugins).toEqual([
+      'postcss-import',
+      'postcss-url',
+      'nuxt-test',
+      'postcss-preset-env',
+      'cssnano'
+    ])
+  })
+
+  test('/stateless', async () => {
+    const window = await nuxt.server.renderAndGetWindow(url('/stateless'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<h1>My component!</h1>')
+    // Check render:routeDone hook called
+    expect(nuxt.__hook_render_routeDone__).toBe('/stateless')
+    window.close()
+  })
+
+  // test('/_nuxt/test.hot-update.json should returns empty html', async t => {
+  //   try {
+  //     await rp(url('/_nuxt/test.hot-update.json'))
+  //   } catch (err) {
+  //     t.is(err.statusCode, 404)
+  //     t.is(err.response.body, '')
+  //   }
+  // })
+
+  test('/__open-in-editor (open-in-editor)', async () => {
+    const { body } = await rp(url('/__open-in-editor?file=pages/index.vue'))
+    expect(body).toBe('')
+  })
+
+  test('/__open-in-editor should return error (open-in-editor)', async () => {
+    await expect(rp(url('/__open-in-editor?file='))).rejects.toMatchObject({
+      response: {
+        statusCode: 500,
+        body: 'launch-editor-middleware: required query param "file" is missing.'
+      }
+    })
+  })
+
+  test('/error should return error stack trace (Youch)', async () => {
+    await expect(nuxt.server.renderAndGetWindow(url('/error'))).rejects.toMatchObject({
+      response: { statusCode: 500 }
+    })
+  })
+
+  test('/error should return json format error (Youch)', async () => {
+    const opts = {
+      headers: {
+        accept: 'application/json'
+      }
+    }
+    await expect(rp(url('/error'), opts)).rejects.toMatchObject({
+      response: {
+        statusCode: 500,
+        headers: {
+          'content-type': 'text/json; charset=utf-8'
+        }
+      }
+    })
+  })
+
+  test('/ should display ssr log in collapsed group', async () => {
+    const virtualConsole = new jsdom.VirtualConsole()
+    const groupCollapsed = jest.fn()
+    const groupEnd = jest.fn()
+    const log = jest.fn()
+    virtualConsole.on('groupCollapsed', groupCollapsed)
+    virtualConsole.on('groupEnd', groupEnd)
+    virtualConsole.on('log', log)
+
+    await nuxt.server.renderAndGetWindow(url('/'), {
+      virtualConsole
+    })
+
+    expect(groupCollapsed).toHaveBeenCalledWith(
+      '%cNuxt SSR',
+      'background: #2E495E;border-radius: 0.5em;color: white;font-weight: bold;padding: 2px 0.5em;'
+    )
+    expect(groupEnd).toHaveBeenCalled()
+    expect(log).toHaveBeenCalledWith('This is a test ssr log')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await builder.close()
+  })
+})

package/test/dev/basic.dynamic.test.js

@@ -0,0 +1,77 @@
+import path from 'path'
+import { readFileSync } from 'fs'
+import { ResourceLoader } from 'jsdom'
+
+import { loadFixture, getPort, Nuxt, Builder } from '../utils'
+
+let fetchCount = 0
+
+class ProxyLoader extends ResourceLoader {
+  fetch (url, options) {
+    if (url.startsWith('https://cdn.nuxtjs.org')) {
+      fetchCount++
+      const param = url.slice('https://cdn.nuxtjs.org'.length + 1)
+      const file = path.join(nuxt.options.buildDir, 'dist/client', param)
+      const fileContents = readFileSync(file, 'utf-8')
+      return Promise.resolve(Buffer.from(fileContents))
+    }
+
+    return super.fetch(url, options)
+  }
+}
+const resourceLoader = new ProxyLoader()
+
+let port
+let nuxt
+const url = route => 'http://localhost:' + port + route
+
+describe('basic ssr', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('basic')
+    const builderNuxt = new Nuxt(options)
+    await builderNuxt.ready()
+
+    const builder = new Builder(builderNuxt)
+
+    await builder.build()
+
+    const runOptions = await loadFixture('basic', {
+      router: {
+        base: '/path'
+      },
+      build: {
+        publicPath: 'https://cdn.nuxtjs.org'
+      }
+    })
+    nuxt = new Nuxt(runOptions)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, '0.0.0.0')
+  })
+
+  test('dynamic config is injected', async () => {
+    const window = await nuxt.server.renderAndGetWindow(url('/path/'), { resources: resourceLoader })
+
+    expect(window.document.body.innerHTML).toContain('<h1>Index page</h1>')
+
+    expect(window.__NUXT__.config._app.basePath).toBe('/path/')
+    expect(window.__NUXT__.config._app.cdnURL).toBe('https://cdn.nuxtjs.org/')
+    expect(window.__NUXT__.config._app.assetsPath).toBe('/')
+
+    expect(fetchCount).toBeGreaterThan(0)
+  })
+
+  test('dynamic publicPath is used in ssr html', async () => {
+    const { html } = await nuxt.server.renderRoute('/', {
+      resources: resourceLoader
+    })
+
+    expect(html).toContain('<img src="https://cdn.nuxtjs.org/img')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/basic.fail.generate.test.js

@@ -0,0 +1,33 @@
+import { loadFixture, Nuxt, Builder, Generator } from '../utils'
+
+describe('basic fail generate', () => {
+  test('Fail with routes() which throw an error', async () => {
+    const options = await loadFixture('basic', {
+      generate: {
+        routes () {
+          throw new Error('Not today!')
+        }
+      }
+    })
+    const nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    const builder = new Builder(nuxt)
+    builder.build = jest.fn()
+    const generator = new Generator(nuxt, builder)
+
+    await generator.generate().catch((e) => {
+      expect(e.message).toBe('Not today!')
+    })
+  })
+
+  test('Fail when generate.dir equals rootDir', async () => {
+    const options = await loadFixture('basic', {
+      generate: { dir: '../basic' }
+    })
+
+    expect(() => {
+      new Nuxt(options) /* eslint-disable-line no-new */
+    }).toThrow(/options.generate.dir cannot be/)
+  })
+})

package/test/dev/basic.generate.test.js

@@ -0,0 +1,286 @@
+import { existsSync, writeFileSync } from 'fs'
+import http from 'http'
+import { resolve } from 'path'
+import { remove } from 'fs-extra'
+import serveStatic from 'serve-static'
+import finalhandler from 'finalhandler'
+import { TARGETS } from '@nuxt/utils'
+import { Builder, Generator, getPort, loadFixture, Nuxt, rp, listPaths, equalOrStartsWith } from '../utils'
+
+let port
+const url = route => 'http://localhost:' + port + route
+const rootDir = resolve(__dirname, '..', 'fixtures/basic')
+const distDir = resolve(rootDir, '.nuxt-generate')
+
+let builder
+let server = null
+let generator = null
+let pathsBefore
+let changedFileName
+
+describe('basic generate', () => {
+  beforeAll(async () => {
+    const config = await loadFixture('basic', {
+      generate: {
+        static: false,
+        dir: '.nuxt-generate'
+      },
+      publicRuntimeConfig: {
+        generated: true
+      }
+    })
+    const nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    pathsBefore = listPaths(nuxt.options.rootDir)
+
+    // Make sure our check for changed files is really working
+    changedFileName = resolve(nuxt.options.generate.dir, '..', '.nuxt-generate', '.nuxt-generate-changed')
+    nuxt.hook('generate:done', () => {
+      writeFileSync(changedFileName, '')
+    })
+    nuxt.hook('export:page', ({ page, errors }) => {
+      if (errors.length && page.route.includes('/skip-on-fail')) {
+        page.exclude = true
+      }
+    })
+
+    builder = new Builder(nuxt)
+    builder.build = jest.fn()
+    generator = new Generator(nuxt, builder)
+
+    await generator.generate()
+
+    const serve = serveStatic(distDir)
+    server = http.createServer((req, res) => {
+      serve(req, res, finalhandler(req, res))
+    })
+
+    port = await getPort()
+    server.listen(port)
+  })
+
+  test('Check builder', () => {
+    expect(builder.bundleBuilder.buildContext.target).toBe(TARGETS.static)
+    expect(builder.build).toHaveBeenCalledTimes(1)
+  })
+
+  test('Check ready hook called', () => {
+    expect(generator.nuxt.__hook_ready_called__).toBe(true)
+  })
+
+  test('Check changed files', () => {
+    // When generating Nuxt we only expect files to change
+    // within nuxt.options.generate.dir, but also allow other
+    // .nuxt dirs for when tests are runInBand
+    const allowChangesDir = resolve(generator.nuxt.options.generate.dir, '..', '.nuxt')
+
+    let changedFileFound = false
+    const paths = listPaths(generator.nuxt.options.rootDir, pathsBefore)
+    paths.forEach((item) => {
+      if (item.path === changedFileName) {
+        changedFileFound = true
+      } else {
+        expect(equalOrStartsWith(allowChangesDir, item.path)).toBe(true)
+      }
+    })
+    expect(changedFileFound).toBe(true)
+  })
+
+  test('Format errors', () => {
+    const error = generator._formatErrors([
+      { type: 'handled', route: '/h1', error: 'page not found' },
+      { type: 'unhandled', route: '/h2', error: { stack: 'unhandled error stack' } }
+    ])
+    expect(error).toMatch(' /h1')
+    expect(error).toMatch(' /h2')
+    expect(error).toMatch('"page not found"')
+    expect(error).toMatch('unhandled error stack')
+  })
+
+  test('/stateless', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/stateless'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<h1>My component!</h1>')
+  })
+
+  test('/store-module', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/store-module'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<h1>mutated</h1>')
+  })
+
+  test('/css', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/css'))
+
+    const headHtml = window.document.head.innerHTML
+    expect(headHtml).toContain('.red{color:red')
+
+    const element = window.document.querySelector('.red')
+    expect(element).not.toBe(null)
+    expect(element.textContent).toContain('This is red')
+    expect(element.className).toBe('red')
+    // t.is(window.getComputedStyle(element), 'red')
+  })
+
+  test('/stateful', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/stateful'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<div><p>The answer is 42</p></div>')
+  })
+
+  test('/head', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/head'))
+    const html = window.document.body.innerHTML
+    const metas = window.document.getElementsByTagName('meta')
+    expect(window.document.title).toBe('My title - Nuxt')
+    expect(metas[0].getAttribute('data-n-head')).toBe('ssr')
+    expect(metas[1].getAttribute('content')).toBe('my meta')
+    expect(html).toContain('<div><h1>I can haz meta tags</h1></div>')
+  })
+
+  test('/async-data', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/async-data'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<p>Nuxt</p>')
+  })
+
+  test('/fetch', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/fetch'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<code>true</code>')
+    expect(window.__NUXT__.fetch.custom100.fetched).toBe(true)
+  })
+
+  test('/тест雨 (test non ascii route)', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/тест雨'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('Hello unicode')
+  })
+
+  test('/users/1/index.html', async () => {
+    const { body: html } = await rp(url('/users/1/index.html'))
+    expect(html).toContain('<h1>User: 1</h1>')
+    expect(
+      existsSync(resolve(distDir, 'users/1/index.html'))
+    ).toBe(true)
+    expect(existsSync(resolve(distDir, 'users/1.html'))).toBe(false)
+  })
+
+  test('/users/2', async () => {
+    const { body: html } = await rp(url('/users/2'))
+    expect(html).toContain('<h1>User: 2</h1>')
+  })
+
+  test('/users/3 (payload given)', async () => {
+    const { body: html } = await rp(url('/users/3'))
+    expect(html).toContain('<h1>User: 3000</h1>')
+  })
+
+  test('/users/4 -> Not found', async () => {
+    await expect(rp(url('/users/4'))).rejects.toMatchObject({
+      response: {
+        statusCode: 404,
+        body: expect.stringContaining('Cannot GET /users/4')
+      }
+    })
+  })
+
+  test('/validate should not be server-rendered', async () => {
+    const { body: html } = await rp(url('/validate'))
+    expect(html).toContain('<div id="__nuxt"></div>')
+  })
+
+  test.posix('/validate -> should display a 404', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/validate'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('This page could not be found')
+  })
+
+  test('/validate?valid=true', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/validate?valid=true'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('I am valid</h1>')
+  })
+
+  test('/redirect should not be server-rendered', async () => {
+    const { body: html } = await rp(url('/redirect'))
+    expect(html).toContain('<div id="__nuxt"></div>')
+
+    // vue-meta should also not indicate ssr
+    expect(html).toContain('<html>')
+    expect(html).toContain('<meta data-n-head="1" charset="utf-8">')
+  })
+
+  test('/redirect -> check redirected source', async () => {
+    const window = await generator.nuxt.server.renderAndGetWindow(url('/redirect'))
+    const html = window.document.body.innerHTML
+    expect(html).toContain('<h1>Index page</h1>')
+  })
+
+  test('/users/1 not found', async () => {
+    await remove(resolve(distDir, 'users'))
+    await expect(rp(url('/users/1'))).rejects.toMatchObject({
+      response: {
+        statusCode: 404,
+        body: expect.stringContaining('Cannot GET /users/1')
+      }
+    })
+  })
+
+  test('nuxt re-generating with no subfolders', async () => {
+    generator.nuxt.options.generate.subFolders = false
+    generator.getAppRoutes = jest.fn(() => [])
+    await expect(generator.generate()).resolves.toBeTruthy()
+  })
+
+  test('/users/1.html', async () => {
+    const { body } = await rp(url('/users/1.html'))
+    expect(body).toContain('<h1>User: 1</h1>')
+    expect(existsSync(resolve(distDir, 'users/1.html'))).toBe(true)
+    expect(
+      existsSync(resolve(distDir, 'users/1/index.html'))
+    ).toBe(false)
+  })
+
+  test('/-ignored', async () => {
+    await expect(rp(url('/-ignored'))).rejects.toMatchObject({
+      response: {
+        statusCode: 404,
+        body: expect.stringContaining('Cannot GET /-ignored')
+      }
+    })
+  })
+
+  test('/ignored.test', async () => {
+    await expect(rp(url('/ignored.test'))).rejects.toMatchObject({
+      response: {
+        statusCode: 404,
+        body: expect.stringContaining('Cannot GET /ignored.test')
+      }
+    })
+  })
+
+  test('creates /200.html as fallback', async () => {
+    const { body: html } = await rp(url('/200.html'))
+    expect(html.includes('<h1>Index page</h1>')).toBe(false)
+    expect(html.includes('data-server-rendered')).toBe(false)
+    expect(existsSync(resolve(distDir, '200.html'))).toBe(true)
+    expect(existsSync(resolve(distDir, '404.html'))).toBe(false)
+  })
+
+  test('Checke skipped files', () => {
+    expect(
+      existsSync(resolve(distDir, 'skip-on-fail/fail.html'))
+    ).toBe(false)
+
+    expect(
+      existsSync(resolve(distDir, 'skip-on-fail/success.html'))
+    ).toBe(true)
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await server.close()
+  })
+})

package/test/dev/basic.plugins.test.js

@@ -0,0 +1,51 @@
+import { getPort, loadFixture, Nuxt } from '../utils'
+
+let port
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+
+describe('plugins', () => {
+  beforeAll(async () => {
+    const config = await loadFixture('basic')
+    nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('/', async () => {
+    const window = await nuxt.server.renderAndGetWindow(url('/'))
+    expect(window.__test_plugin).toBe(true)
+  })
+
+  test('inject fails if value is undefined', async () => {
+    // inject('injectedProperty', undefined)
+    await expect(nuxt.renderRoute('/?injectValue=undefined')).rejects.toThrowError('inject(\'injectedProperty\', value) has no value provided')
+  })
+
+  test('inject succeeds if value is defined but evaluates to false', async () => {
+    // inject('injectedProperty', null)
+    await expect(nuxt.renderRoute('/?injectValue=null')).resolves.not.toThrowError()
+    // inject('injectedProperty', false)
+    await expect(nuxt.renderRoute('/?injectValue=false')).resolves.not.toThrowError()
+    // inject('injectedProperty', 0)
+    await expect(nuxt.renderRoute('/?injectValue=0')).resolves.not.toThrowError()
+    // inject('injectedProperty', '')
+    await expect(nuxt.renderRoute('/?injectValue=empty')).resolves.not.toThrowError()
+  })
+  test('inject should add to context and prototypes', async () => {
+    const window = await nuxt.server.renderAndGetWindow(url('/?injectValue=foo'))
+    // inject('injectedProperty', 'bar')
+    await expect(window.$nuxt.$injectedProperty).toBe('bar')
+    await expect(window.$nuxt.context.$injectedProperty).toBe('bar')
+    await expect(window.$nuxt.context.app.$injectedProperty).toBe('bar')
+    await expect(window.$nuxt.$store.$injectedProperty).toBe('bar')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+})

package/test/dev/basic.relative.test.js

@@ -0,0 +1,41 @@
+import { loadFixture, getPort, Nuxt, rp } from '../utils'
+
+let port
+let nuxt
+const url = route => 'http://localhost:' + port + route
+
+const tests = [
+  ['relative publicPath can be used in dev ssr', {
+    build: {
+      publicPath: './_nuxt/'
+    }
+  }],
+  ['relative publicPath can be used in production ssr', {
+    dev: false,
+    build: {
+      publicPath: './_nuxt/'
+    }
+  }]
+]
+
+describe('basic ssr with relative path', () => {
+  tests.forEach(([name, options]) => test(name, async () => {
+    const config = await loadFixture('basic', options)
+    nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+
+    const { html } = await nuxt.server.renderRoute('/')
+
+    expect(html).toContain('<img src="./_nuxt/img')
+    const { 1: imageSrc } = html.match(/<img src="\.(\/_nuxt\/img[^"]*)"/)
+
+    const { statusCode } = await rp(url(imageSrc))
+    expect(statusCode).toBe(200)
+
+    await nuxt.close()
+  }
+  ))
+})