expeditaea 1.0.0

package/test/dev/wp.config.test.js

@@ -0,0 +1,42 @@
+
+import path from 'path'
+import PerfLoader from '../../packages/webpack/src/utils/perf-loader'
+
+describe('webpack configuration', () => {
+  test('performance loader', () => {
+    const js = { name: 'js', poolTimeout: Infinity }
+    const css = { name: 'css', poolTimeout: Infinity }
+    const resolveModule = jest.fn(id => id)
+    PerfLoader.warmup = jest.fn()
+    PerfLoader.warmupAll({ dev: true, resolveModule })
+    expect(PerfLoader.warmup).toHaveBeenCalledTimes(2)
+    expect(PerfLoader.warmup).toHaveBeenCalledWith(js, [
+      'babel-loader',
+      '@babel/preset-env'
+    ])
+    expect(PerfLoader.warmup).toHaveBeenCalledWith(css, ['css-loader'])
+
+    const perfLoader = new PerfLoader(
+      'test-perf',
+      {
+        options: {
+          dev: true
+        },
+        buildOptions: {
+          parallel: true,
+          cache: true
+        }
+      },
+      {
+        resolveModule
+      }
+    )
+    expect(perfLoader.workerPools).toMatchObject({ js, css })
+    const loaders = perfLoader.use('js')
+    const cacheDirectory = path.resolve('node_modules/.cache/cache-loader/test-perf')
+    expect(loaders).toMatchObject([
+      { loader: 'cache-loader', options: { cacheDirectory } },
+      { loader: 'thread-loader', options: js }
+    ])
+  })
+})

package/test/e2e/basic.browser.test.js

@@ -0,0 +1,338 @@
+import Browser from '../utils/browser'
+import { loadFixture, getPort, Nuxt, waitFor } from '../utils'
+
+let port
+const browser = new Browser()
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+let page = null
+
+describe('basic browser', () => {
+  beforeAll(async () => {
+    const config = await loadFixture('basic')
+    nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+
+    await browser.start({
+      // slowMo: 50,
+      // headless: false
+    })
+  })
+
+  test('Open /', async () => {
+    page = await browser.page(url('/'))
+
+    expect(await page.$text('h1')).toBe('Index page')
+  })
+
+  test('/noloading', async () => {
+    const { hook } = await page.nuxt.navigate('/noloading', false)
+    await waitFor(nuxt.options.loading.throttle + 100)
+    let loading = await page.nuxt.loadingData()
+    expect(loading.show).toBe(true)
+    await hook
+    loading = await page.nuxt.loadingData()
+    expect(loading.show).toBe(true)
+    await page.waitForFunction(
+      '$nuxt.$loading.$data.show === false'
+    )
+    await page.waitForFunction(
+      'document.querySelector(\'p\').innerText === \'true\''
+    )
+  })
+
+  test('/stateless', async () => {
+    const { hook } = await page.nuxt.navigate('/stateless', false)
+
+    await hook
+    expect(await page.$text('h1')).toBe('My component!')
+  })
+
+  test('/store-module', async () => {
+    await page.nuxt.navigate('/store-module')
+    expect(await page.$text('h1')).toBe('mutated')
+    expect(await page.evaluate(() => window.__NUXT__.state.clientsideModule.initialised)).toBeTruthy()
+  })
+
+  test('/css', async () => {
+    await page.nuxt.navigate('/css')
+
+    expect(await page.$text('.red', true)).toEqual('This is red')
+    expect(await page.$eval('.red', (red) => {
+      const { color, backgroundColor } = window.getComputedStyle(red)
+      return { color, backgroundColor }
+    })).toEqual({
+      color: 'rgb(255, 0, 0)',
+      backgroundColor: 'rgb(0, 0, 255)'
+    })
+  })
+
+  test.skip('/stateful', async () => {
+    const { hook } = await page.nuxt.navigate('/stateful')
+
+    await hook
+    expect(await page.$text('p')).toBe('The answer is 42')
+  })
+
+  test('/store', async () => {
+    await page.nuxt.navigate('/store')
+
+    expect(await page.$text('h1')).toBe('foo/bar/baz: Vuex Nested Modules')
+    expect(await page.$text('h2')).toBe('index/counter: 1')
+    expect(await page.$text('h3')).toBe('foo/blarg/getVal: 4')
+    expect(await page.$text('h4')).toBe('foo/bab/getBabVal: 10')
+  })
+
+  test('/head', async () => {
+    const msg = new Promise(resolve =>
+      page.on('console', msg => resolve(msg.text()))
+    )
+    await page.nuxt.navigate('/head')
+    const metas = await page.$$attr('meta', 'content')
+
+    expect(await msg).toBe('Body script!')
+    expect(await page.title()).toBe('My title - Nuxt')
+    expect(await page.$text('h1')).toBe('I can haz meta tags')
+    expect(metas[1]).toBe('my meta')
+  })
+
+  test('/async-data', async () => {
+    await page.nuxt.navigate('/async-data')
+
+    expect(await page.$text('p')).toBe('Nuxt')
+  })
+
+  test('/await-async-data', async () => {
+    await page.nuxt.navigate('/await-async-data')
+
+    expect(await page.$text('p')).toBe('Await Nuxt')
+  })
+
+  test('/callback-async-data', async () => {
+    await page.nuxt.navigate('/callback-async-data')
+
+    expect(await page.$text('p')).toBe('Callback Nuxt')
+  })
+
+  test('/users/1', async () => {
+    await page.nuxt.navigate('/users/1')
+
+    expect(await page.$text('h1')).toBe('User: 1')
+  })
+
+  test('/scroll-to-top with scrollToTop set to true', async () => {
+    const page = await browser.page(url('/scroll-to-top'))
+    await page.evaluate(() => window.scrollBy(0, window.innerHeight))
+    await page.nuxt.navigate('/scroll-to-top/scroll-to-top-true')
+    const pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBe(0)
+    page.close()
+  })
+
+  test('/scroll-to-top with scrollToTop set to false', async () => {
+    const page = await browser.page(url('/scroll-to-top'))
+    await page.evaluate(() => window.scrollBy(0, window.innerHeight))
+    await page.nuxt.navigate('/scroll-to-top/scroll-to-top-false')
+    const pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    page.close()
+  })
+
+  test('/scroll-to-top in the same page', async () => {
+    const page = await browser.page(url('/scroll-to-top'))
+    await page.evaluate(() => window.scrollBy(0, window.innerHeight))
+    await page.nuxt.navigate('/scroll-to-top?test=1')
+    const pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    page.close()
+  })
+
+  test('/scroll-to-top in the same page with watchQuery: true', async () => {
+    const page = await browser.page(url('/scroll-to-top/watch-query-true'))
+    await page.evaluate(() => window.scrollBy(0, window.innerHeight))
+    await page.nuxt.navigate('/scroll-to-top/watch-query-true?test=1')
+    let pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBe(0)
+    await page.nuxt.go(-1)
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    page.close()
+  })
+
+  test('/scroll-to-top in the same page with watchQuery array', async () => {
+    const page = await browser.page(url('/scroll-to-top/watch-query-array'))
+    await page.evaluate(() => window.scrollBy(0, window.innerHeight))
+    await page.nuxt.navigate('/scroll-to-top/watch-query-array?other=1')
+    let pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    await page.nuxt.go(-1)
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    await page.nuxt.navigate('/scroll-to-top/watch-query-array?test=1')
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBe(0)
+    await page.nuxt.go(-1)
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    page.close()
+  })
+
+  test('/scroll-to-top in the same page with watchQuery function', async () => {
+    const page = await browser.page(url('/scroll-to-top/watch-query-fn'))
+    await page.evaluate(() => window.scrollBy(0, window.innerHeight))
+    await page.nuxt.navigate('/scroll-to-top/watch-query-fn?other=1')
+    let pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    await page.nuxt.go(-1)
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBeGreaterThan(0)
+    await page.nuxt.navigate('/scroll-to-top/watch-query-fn?test=1')
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBe(0)
+    await page.nuxt.go(-1)
+    pageYOffset = await page.evaluate(() => window.pageYOffset)
+    expect(pageYOffset).toBe(0)
+    page.close()
+  })
+
+  test('/validate should display a 404', async () => {
+    await page.nuxt.navigate('/validate')
+
+    const error = await page.nuxt.errorData()
+
+    expect(error.statusCode).toBe(404)
+    expect(error.message).toBe('This page could not be found')
+  })
+
+  test('/validate-async should display a 404', async () => {
+    await page.nuxt.navigate('/validate-async')
+
+    const error = await page.nuxt.errorData()
+
+    expect(error.statusCode).toBe(404)
+    expect(error.message).toBe('This page could not be found')
+  })
+
+  test('/validate?valid=true', async () => {
+    await page.nuxt.navigate('/validate?valid=true')
+
+    expect(await page.$text('h1')).toBe('I am valid')
+  })
+
+  test('/validate-async?valid=true', async () => {
+    await page.nuxt.navigate('/validate-async?valid=true')
+
+    expect(await page.$text('h1')).toBe('I am valid')
+  })
+
+  test('/redirect', async () => {
+    await page.nuxt.navigate('/redirect')
+
+    expect(await page.$text('h1')).toBe('Index page')
+  })
+
+  test('/error', async () => {
+    await page.nuxt.navigate('/error')
+
+    expect(await page.nuxt.errorData()).toEqual({ message: 'Error mouahahah', statusCode: 500 })
+    expect(await page.$text('.title')).toBe('Error mouahahah')
+  })
+
+  test('/error2', async () => {
+    await page.nuxt.navigate('/error2')
+
+    expect(await page.$text('.title')).toBe('Custom error')
+    expect(await page.nuxt.errorData()).toEqual({ message: 'Custom error', statusCode: 500, customProp: 'ezpz' })
+  })
+
+  test('/redirect-middleware', async () => {
+    await page.nuxt.navigate('/redirect-middleware')
+
+    expect(await page.$text('h1')).toBe('Index page')
+  })
+
+  test('/redirect-external', async () => {
+    // New page for redirecting to external link.
+    const page = await browser.page(url('/'))
+
+    await page.nuxt.navigate('/redirect-external', false)
+
+    await page.waitForFunction(
+      () => window.location.href === 'https://nuxtjs.org/docs/2.x/features/data-fetching/'
+    )
+    page.close()
+  })
+
+  test('/redirect-name', async () => {
+    await page.nuxt.navigate('/redirect-name')
+
+    expect(await page.$text('h1')).toBe('My component!')
+  })
+
+  test('/no-ssr', async () => {
+    await page.nuxt.navigate('/no-ssr')
+
+    expect(await page.$text('h1')).toBe('Displayed only on client-side')
+  })
+
+  test('/meta', async () => {
+    await page.nuxt.navigate('/meta')
+
+    const state = await page.nuxt.storeState()
+    expect(state.meta).toEqual([{ works: true }])
+  })
+
+  test('/fn-midd', async () => {
+    await page.nuxt.navigate('/fn-midd')
+
+    expect(await page.$text('.title')).toBe('You need to ask the permission')
+    expect(await page.nuxt.errorData()).toEqual({
+      message: 'You need to ask the permission',
+      statusCode: 403
+    })
+  })
+
+  test('/fn-midd?please=true', async () => {
+    await page.nuxt.navigate('/fn-midd?please=true')
+
+    const h1 = await page.$text('h1')
+    expect(h1.includes('Date:')).toBe(true)
+  })
+
+  test('/router-guard', async () => {
+    await page.nuxt.navigate('/router-guard')
+
+    const p = await page.$text('p')
+    expect(p).toBe('Nuxt')
+  })
+
+  test('/refresh-page-data', async () => {
+    const page = await browser.page(url('/refresh-page-data'))
+    let h1 = await page.$text('h1')
+    expect(h1).toContain('Hello from server')
+    await page.evaluate($nuxt => $nuxt.refresh(), page.$nuxt)
+    h1 = await page.$text('h1')
+    expect(h1).toContain('Hello from client')
+    page.close()
+  })
+
+  test('/redirection/no loop', async () => {
+    const page = await browser.page(url('/redirection/no loop'))
+    expect(await page.$text('h1')).toContain('Redirected page')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+
+  // Stop browser
+  afterAll(async () => {
+    await page.close()
+    await browser.close()
+  })
+})

package/test/e2e/basic.vue-config.test.js

@@ -0,0 +1,58 @@
+import Browser from '../utils/browser'
+import { getPort, loadFixture, Nuxt } from '../utils'
+
+let port
+const browser = new Browser()
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+let page = null
+
+const startServer = async (type = 'basic') => {
+  const config = await loadFixture(type)
+  nuxt = new Nuxt(config)
+  await nuxt.ready()
+
+  port = await getPort()
+  await nuxt.server.listen(port, 'localhost')
+
+  return nuxt
+}
+
+describe('basic vue-config', () => {
+  beforeAll(async () => {
+    await browser.start({
+      // slowMo: 50,
+      // headless: false
+    })
+  })
+
+  test('default', async () => {
+    nuxt = await startServer()
+    expect(nuxt.options.vue.config).toEqual({ silent: true, performance: false })
+    page = await browser.page(url('/config'))
+
+    expect(await page.$text('#silent', true)).toBe('true')
+    expect(await page.$text('#performance', true)).toBe('false')
+  })
+
+  test('explicit', async () => {
+    nuxt = await startServer('config-explicit')
+    page = await browser.page(url('/config'))
+
+    expect(nuxt.options.vue.config).toEqual({ silent: false, performance: true, devtools: true })
+
+    expect(await page.$text('#silent', true)).toBe('false')
+    expect(await page.$text('#performance', true)).toBe('true')
+    expect(await page.$text('#devtools', true)).toBe('true')
+  })
+
+  afterEach(async () => {
+    await nuxt.close()
+  })
+
+  afterAll(async () => {
+    await page.close()
+    await browser.close()
+  })
+})

package/test/e2e/children.patch.browser.test.js

@@ -0,0 +1,166 @@
+import Browser from '../utils/browser'
+import { loadFixture, getPort, Nuxt, waitFor } from '../utils'
+
+let port
+const browser = new Browser()
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+let page
+const dates = {}
+
+describe('children patch (browser)', () => {
+  beforeAll(async () => {
+    const options = await loadFixture('children')
+    nuxt = new Nuxt(options)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+  })
+
+  test('Start browser', async () => {
+    expect.assertions(0) // suppress 'no assertions' warning
+    await browser.start({
+      // slowMo: 50,
+      // headless: false
+    })
+  })
+
+  test('Loading /patch and keep', async () => {
+    page = await browser.page(url('/patch'))
+
+    const h1 = await page.$text('h1')
+    expect(h1.includes('patch:')).toBe(true)
+    const h2 = await page.$text('h2')
+    expect(h2).toBe('Index')
+    dates.patch = await page.$text('[data-date-patch]')
+  })
+
+  describe('refresh child component if param changed', () => {
+    test('Navigate to /patch/1', async () => {
+      const { hook } = await page.nuxt.navigate('/patch/1', false)
+      await hook
+
+      const h2 = await page.$text('h2')
+      expect(h2.includes('_id:')).toBe(true)
+      dates.id = await page.$text('[data-date-id]')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+    })
+
+    test('Navigate to /patch/2', async () => {
+      await page.nuxt.navigate('/patch/2')
+      const date = await page.$text('[data-date-id]')
+
+      expect(await page.$text('h3')).toBe('Index')
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(+dates.id < +date).toBe(true)
+      dates.id = date
+    })
+  })
+
+  describe('resue component if only query is changed', () => {
+    test('Navigate to /patch/2?test=true', async () => {
+      await page.nuxt.navigate('/patch/2?test=true')
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+    })
+
+    test('Navigate to /patch/2#test', async () => {
+      await page.nuxt.navigate('/patch/2#test')
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+    })
+  })
+
+  describe('refresh child component if param is changed', () => {
+    test('Navigate to /patch/2/child', async () => {
+      await page.nuxt.navigate('/patch/2/child')
+      dates.child = await page.$text('[data-date-child]')
+      dates.slug = await page.$text('[data-date-child-slug]')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+      expect(+dates.child > +dates.id).toBe(true)
+      expect(+dates.slug > +dates.child).toBe(true)
+    })
+
+    test('Navigate to /patch/2/child/1', async () => {
+      await page.nuxt.navigate('/patch/2/child/1')
+      const date = await page.$text('[data-date-child-slug]')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+      expect(dates.child).toBe(await page.$text('[data-date-child]'))
+      expect(+date > +dates.slug).toBe(true)
+      dates.slug = date
+    })
+
+    test('Navigate to /patch/2/child/1?foo=bar', async () => {
+      await page.nuxt.navigate('/patch/2/child/1?foo=bar')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+      expect(dates.child).toBe(await page.$text('[data-date-child]'))
+      expect(dates.slug).toBe(await page.$text('[data-date-child-slug]'))
+    })
+
+    test('Search a country', async () => {
+      const countries = await page.$$text('[data-test-search-result]')
+      expect(countries.length).toBe(5)
+
+      await page.type('[data-test-search-input]', 'gu')
+
+      await waitFor(250)
+      const newCountries = await page.$$text('[data-test-search-result]', true)
+      expect(newCountries.length).toBe(1)
+      expect(newCountries).toEqual(['Guinea'])
+      expect(await page.nuxt.routeData()).toEqual({
+        path: '/patch/2/child/1',
+        query: {
+          foo: 'bar',
+          q: 'gu'
+        }
+      })
+    })
+  })
+
+  describe('reuse child component if param is changed but watchParam is false', () => {
+    test('Navigate to /patch/2/reuse', async () => {
+      await page.nuxt.navigate('/patch/2/reuse')
+      dates.slug = await page.$text('[data-date-slug]')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+      expect(+dates.child > +dates.id).toBe(true)
+    })
+
+    test('Navigate to /patch/2/reuse/1', async () => {
+      await page.nuxt.navigate('/patch/2/reuse/1')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+      expect(dates.slug).toBe(await page.$text('[data-date-slug]'))
+    })
+
+    test('Navigate to /patch/2/reuse/2', async () => {
+      await page.nuxt.navigate('/patch/2/reuse/2')
+
+      expect(dates.patch).toBe(await page.$text('[data-date-patch]'))
+      expect(dates.id).toBe(await page.$text('[data-date-id]'))
+      expect(dates.slug).toBe(await page.$text('[data-date-slug]'))
+    })
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+
+  // Stop browser
+  afterAll(async () => {
+    await page.close()
+    await browser.close()
+  })
+})

package/test/e2e/error.test.js

@@ -0,0 +1,71 @@
+import Browser from '../utils/browser'
+import { loadFixture, getPort, Nuxt } from '../utils'
+
+let port
+const browser = new Browser()
+const url = route => 'http://localhost:' + port + route
+
+let nuxt = null
+let page = null
+
+describe('basic browser', () => {
+  beforeAll(async () => {
+    const config = await loadFixture('error')
+    nuxt = new Nuxt(config)
+    await nuxt.ready()
+
+    port = await getPort()
+    await nuxt.server.listen(port, 'localhost')
+
+    await browser.start({
+      // slowMo: 50,
+      // headless: false
+    })
+  })
+
+  test('Open /', async () => {
+    page = await browser.page(url('/'))
+
+    expect(await page.$text('h1')).toBe('Error Loop incoming page')
+  })
+
+  test('/squared doesnt loop due to error on error page', async () => {
+    await page.nuxt.navigate('/squared')
+
+    expect(await page.$text('header')).toBe('Error layout')
+    expect(await page.$text('h2')).toBe('An error occurred while showing the error page')
+  })
+
+  test('/about loads normally', async () => {
+    await page.nuxt.navigate('/about')
+
+    expect(await page.$text('h1')).toBe('About')
+  })
+
+  test('/about error layout after click', async () => {
+    const transitionPromise = page.evaluate(async ($nuxt) => {
+      await new Promise(resolve => $nuxt.$once('triggerScroll', resolve))
+    }, page.$nuxt)
+
+    await page.click('button')
+    await transitionPromise
+    expect(await page.$text('header')).toBe('Error layout')
+  })
+
+  test('/info prints empty page', async () => {
+    await page.nuxt.navigate('/info')
+
+    expect(await page.$text('#__layout')).toBe('')
+  })
+
+  // Close server and ask nuxt to stop listening to file changes
+  afterAll(async () => {
+    await nuxt.close()
+  })
+
+  // Stop browser
+  afterAll(async () => {
+    await page.close()
+    await browser.close()
+  })
+})