From fffe7419869ac2b0256d288864646cc2c9716b93 Mon Sep 17 00:00:00 2001
From: pimlie <pimlie@hotmail.com>
Date: Sun, 17 Dec 2017 20:30:26 +0100
Subject: [PATCH 1/2] Use console helper with sinon

Add stdout/stderr to console helpers

Remove separate nosubfolders test file in favor of inclusion in basic.generate

Add build.stats to silence webpack output

Add .always to after hooks: (1) fixes issue with basic.dev test that watch.js is empty when one of the test fails and (2) fixes that sometimes when running multiple tests that failed after eachother the port is still used as the server did not automatically get killed

Change all init nuxt before test to serial tests and add tests for DONE and OPEN logs
---
 .gitignore                               |   4 +-
 package.json                             |   2 +-
 test/basic.csr.test.js                   |  73 +++++++-----
 test/basic.dev.test.js                   |  38 ++++---
 test/basic.fail.generate.test.js         |  24 ++--
 test/basic.generate.nosubfolders.test.js | 138 -----------------------
 test/basic.generate.test.js              |  98 ++++++++++------
 test/basic.ssr.test.js                   | 102 ++++++++---------
 test/children.patch.test.js              |  56 +++++----
 test/children.test.js                    |  25 ++--
 test/cli.test.js                         |   6 +-
 test/debug.test.js                       |  52 +++++++--
 test/deprecate.test.js                   |  40 +++----
 test/dll.test.js                         |  14 ++-
 test/dynamic-routes.test.js              |  17 ++-
 test/error.test.js                       |  46 +++++---
 test/express.test.js                     |  21 ++--
 test/fixtures/debug/nuxt.config.js       |   4 +
 test/fixtures/deprecate/nuxt.config.js   |   1 +
 test/fixtures/dll/nuxt.config.js         |   1 +
 test/fixtures/module/nuxt.config.js      |   3 +
 test/fixtures/spa/nuxt.config.js         |   6 +-
 test/fixtures/ssr/nuxt.config.js         |  10 ++
 test/fixtures/with-config/nuxt.config.js |   1 +
 test/helpers/console.js                  |  36 +++++-
 test/index.test.js                       |   6 +-
 test/module.test.js                      |  44 ++++----
 test/spa.test.js                         |  44 ++++++--
 test/ssr.test.js                         |  32 +++---
 test/with-config.test.js                 |  55 ++++-----
 30 files changed, 543 insertions(+), 456 deletions(-)
 delete mode 100644 test/basic.generate.nosubfolders.test.js
 create mode 100644 test/fixtures/ssr/nuxt.config.js

diff --git a/.gitignore b/.gitignore
index 6b2d6f7e1d..0d87892d25 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,7 +9,7 @@ package-lock.json
 npm-debug.log*
 
 # Other
-.nuxt
+.nuxt*
 .cache
 
 # Dist folder
@@ -47,4 +47,4 @@ coverage
 .AppleDesktop
 Network Trash Folder
 Temporary Items
-.apdisk
\ No newline at end of file
+.apdisk
diff --git a/package.json b/package.json
index e87683bb05..55019696cd 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
     ]
   },
   "scripts": {
-    "test": "npm run lint && nyc ava --verbose --serial test/ -- && nyc report --reporter=html",
+    "test": "npm run lint && nyc ava --verbose test/ -- && nyc report --reporter=html",
     "coverage": "nyc report --reporter=text-lcov > coverage.lcov && codecov",
     "lint": "eslint --ext .js,.vue bin/* build/ lib/ test/ examples/",
     "precommit": "npm run lint",
diff --git a/test/basic.csr.test.js b/test/basic.csr.test.js
index 94fada4228..b8108dae16 100644
--- a/test/basic.csr.test.js
+++ b/test/basic.csr.test.js
@@ -2,6 +2,7 @@ import test from 'ava'
 import { resolve } from 'path'
 import { Nuxt, Builder } from '..'
 import * as browser from './helpers/browser'
+import { interceptLog } from './helpers/console'
 
 const port = 4003
 const url = (route) => 'http://localhost:' + port + route
@@ -10,36 +11,46 @@ let nuxt = null
 let page = null
 
 // Init nuxt.js and create server listening on localhost:4003
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const options = {
     rootDir: resolve(__dirname, 'fixtures/basic'),
-    dev: false,
+    buildDir: '.nuxt-csr',
+    dev: true,
     head: {
       titleTemplate(titleChunk) {
         return titleChunk ? `${titleChunk} - Nuxt.js` : 'Nuxt.js'
       }
+    },
+    build: {
+      stats: false
     }
   }
-  nuxt = new Nuxt(options)
-  await new Builder(nuxt).build()
 
-  await nuxt.listen(port, 'localhost')
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(options)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
-test.before('Start browser', async t => {
+test.serial('Start browser', async t => {
+  t.plan(0) // suppress 'no assertions' warning
   await browser.start({
     // slowMo: 50,
     // headless: false
   })
 })
 
-test('Open /', async t => {
+test.serial('Open /', async t => {
   page = await browser.page(url('/'))
 
   t.is(await page.$text('h1'), 'Index page')
 })
 
-test('/stateless', async t => {
+test.serial('/stateless', async t => {
   const { hook } = await page.nuxt.navigate('/stateless', false)
   const loading = await page.nuxt.loadingData()
 
@@ -48,27 +59,27 @@ test('/stateless', async t => {
   t.is(await page.$text('h1'), 'My component!')
 })
 
-test('/css', async t => {
+test.serial('/css', async t => {
   await page.nuxt.navigate('/css')
 
   t.is(await page.$text('.red'), 'This is red')
   t.is(await page.$eval('.red', (red) => window.getComputedStyle(red).color), 'rgb(255, 0, 0)')
 })
 
-test('/stateful', async t => {
+test.serial('/stateful', async t => {
   await page.nuxt.navigate('/stateful')
 
   t.is(await page.$text('p'), 'The answer is 42')
 })
 
-test('/store', async t => {
+test.serial('/store', async t => {
   await page.nuxt.navigate('/store')
 
   t.is(await page.$text('h1'), 'Vuex Nested Modules')
   t.is(await page.$text('p'), '1')
 })
 
-test('/head', async t => {
+test.serial('/head', async t => {
   const msg = new Promise((resolve) => page.on('console', (msg) => resolve(msg.text)))
   await page.nuxt.navigate('/head')
   const metas = await page.$$attr('meta', 'content')
@@ -79,31 +90,31 @@ test('/head', async t => {
   t.is(metas[0], 'my meta')
 })
 
-test('/async-data', async t => {
+test.serial('/async-data', async t => {
   await page.nuxt.navigate('/async-data')
 
   t.is(await page.$text('p'), 'Nuxt.js')
 })
 
-test('/await-async-data', async t => {
+test.serial('/await-async-data', async t => {
   await page.nuxt.navigate('/await-async-data')
 
   t.is(await page.$text('p'), 'Await Nuxt.js')
 })
 
-test('/callback-async-data', async t => {
+test.serial('/callback-async-data', async t => {
   await page.nuxt.navigate('/callback-async-data')
 
   t.is(await page.$text('p'), 'Callback Nuxt.js')
 })
 
-test('/users/1', async t => {
+test.serial('/users/1', async t => {
   await page.nuxt.navigate('/users/1')
 
   t.is(await page.$text('h1'), 'User: 1')
 })
 
-test('/validate should display a 404', async t => {
+test.serial('/validate should display a 404', async t => {
   await page.nuxt.navigate('/validate')
   const error = await page.nuxt.errorData()
 
@@ -111,39 +122,39 @@ test('/validate should display a 404', async t => {
   t.is(error.message, 'This page could not be found')
 })
 
-test('/validate?valid=true', async t => {
+test.serial('/validate?valid=true', async t => {
   await page.nuxt.navigate('/validate?valid=true')
 
   t.is(await page.$text('h1'), 'I am valid')
 })
 
-test('/redirect', async t => {
+test.serial('/redirect', async t => {
   await page.nuxt.navigate('/redirect')
 
   t.is(await page.$text('h1'), 'Index page')
 })
 
-test('/error', async t => {
+test.serial('/error', async t => {
   await page.nuxt.navigate('/error')
 
   t.deepEqual(await page.nuxt.errorData(), { statusCode: 500 })
   t.is(await page.$text('.title'), 'Error mouahahah')
 })
 
-test('/error2', async t => {
+test.serial('/error2', async t => {
   await page.nuxt.navigate('/error2')
 
   t.is(await page.$text('.title'), 'Custom error')
   t.deepEqual(await page.nuxt.errorData(), { message: 'Custom error' })
 })
 
-test('/redirect2', async t => {
+test.serial('/redirect2', async t => {
   await page.nuxt.navigate('/redirect2')
 
   t.is(await page.$text('h1'), 'Index page')
 })
 
-test('/redirect3', async t => {
+test.serial('/redirect3', async t => {
   // New page for redirecting to external link.
   const page = await browser.page(url('/'))
   await page.nuxt.navigate('/redirect3', false)
@@ -152,44 +163,44 @@ test('/redirect3', async t => {
   t.pass()
 })
 
-test('/no-ssr', async t => {
+test.serial('/no-ssr', async t => {
   await page.nuxt.navigate('/no-ssr')
 
   t.is(await page.$text('h1'), 'Displayed only on client-side')
 })
 
-test('/meta', async t => {
+test.serial('/meta', async t => {
   await page.nuxt.navigate('/meta')
 
   const state = await page.nuxt.storeState()
   t.deepEqual(state.meta, [{ works: true }])
 })
 
-test('/fn-midd', async t => {
+test.serial('/fn-midd', async t => {
   await page.nuxt.navigate('/fn-midd')
 
   t.is(await page.$text('.title'), 'You need to ask the permission')
   t.deepEqual(await page.nuxt.errorData(), { message: 'You need to ask the permission', statusCode: 403 })
 })
 
-test('/fn-midd?please=true', async t => {
+test.serial('/fn-midd?please=true', async t => {
   await page.nuxt.navigate('/fn-midd?please=true')
 
   const h1 = await page.$text('h1')
   t.true(h1.includes('Date:'))
 })
 
-test('/router-guard', async t => {
+test.serial('/router-guard', async t => {
   await page.nuxt.navigate('/router-guard')
 
   t.is(await page.$text('p'), 'Nuxt.js')
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
 
-test.after('Stop browser', async t => {
+test.after.always('Stop browser', async t => {
   await browser.stop()
 })
diff --git a/test/basic.dev.test.js b/test/basic.dev.test.js
index af13547414..efdf90e3f4 100644
--- a/test/basic.dev.test.js
+++ b/test/basic.dev.test.js
@@ -1,6 +1,6 @@
 import test from 'ava'
 import { resolve } from 'path'
-import { interceptLog, release } from './helpers/console'
+import { intercept, release } from './helpers/console'
 import { Nuxt, Builder, Utils } from '..'
 import { truncateSync, readFileSync, writeFileSync } from 'fs'
 
@@ -13,32 +13,39 @@ const pluginContent = readFileSync(pluginPath)
 let nuxt = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const options = {
     rootDir,
+    buildDir: '.nuxt-dev',
     dev: true,
     build: {
+      stats: false,
       profile: true
     },
     plugins: [
       '~/plugins/watch.js'
     ]
   }
-  nuxt = new Nuxt(options)
-  await new Builder(nuxt).build()
 
-  await nuxt.listen(port, 'localhost')
+  const spies = await intercept({ log: true, stderr: true }, async () => {
+    nuxt = new Nuxt(options)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(spies.log.calledWithMatch('DONE'))
+  t.true(spies.log.calledWithMatch('OPEN'))
 })
 
-test('remove mixins in live reloading', async t => {
-  const logSpy = await interceptLog()
+test.serial('remove mixins in live reloading', async t => {
+  const spies = await intercept()
   await nuxt.renderRoute(url('/'))
-  t.true(logSpy.calledWith('I am mixin'))
+  t.true(spies.log.calledWith('I am mixin'))
 
   truncateSync(pluginPath)
   await new Promise(async (resolve, reject) => {
     let waitTimes = 0
-    while (logSpy.neverCalledWithMatch(/Compiled successfully/)) {
+    while (spies.log.neverCalledWithMatch(/Compiled successfully/)) {
       if (waitTimes++ >= 20) {
         t.fail('Dev server doesn\'t reload after 2000ms')
         reject(Error())
@@ -47,16 +54,21 @@ test('remove mixins in live reloading', async t => {
     }
     resolve()
   })
-  logSpy.reset()
+  spies.log.reset()
+
   await nuxt.renderRoute(url('/'))
-  t.true(logSpy.neverCalledWith('I am mixin'))
+  t.true(spies.log.neverCalledWith('I am mixin'))
+  t.is(spies.error.getCall(0).args[0].statusCode, 404)
   release()
 })
 
-test('/stateless', async t => {
+test.serial('/stateless', async t => {
+  const spies = await intercept()
   const window = await nuxt.renderAndGetWindow(url('/stateless'))
   const html = window.document.body.innerHTML
   t.true(html.includes('<h1>My component!</h1>'))
+  t.true(spies.info.calledWithMatch('You are running Vue in development mode.'))
+  release()
 })
 
 // test('/_nuxt/test.hot-update.json should returns empty html', async t => {
@@ -69,7 +81,7 @@ test('/stateless', async t => {
 // })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', async t => {
+test.after.always('Closing server and nuxt.js', async t => {
   writeFileSync(pluginPath, pluginContent)
   await nuxt.close()
 })
diff --git a/test/basic.fail.generate.test.js b/test/basic.fail.generate.test.js
index 79653d3593..65e8874e75 100644
--- a/test/basic.fail.generate.test.js
+++ b/test/basic.fail.generate.test.js
@@ -1,22 +1,32 @@
 import test from 'ava'
 import { resolve } from 'path'
 import { Nuxt, Builder, Generator } from '..'
+import { intercept } from './helpers/console'
 
 test('Fail with routes() which throw an error', async t => {
   const options = {
     rootDir: resolve(__dirname, 'fixtures/basic'),
+    buildDir: '.nuxt-fail',
     dev: false,
+    build: {
+      stats: false
+    },
     generate: {
       async routes() {
         throw new Error('Not today!')
       }
     }
   }
-  const nuxt = new Nuxt(options)
-  const builder = new Builder(nuxt)
-  const generator = new Generator(nuxt, builder)
-  return generator.generate()
-    .catch((e) => {
-      t.true(e.message === 'Not today!')
-    })
+  const spies = await intercept(async () => {
+    const nuxt = new Nuxt(options)
+    const builder = new Builder(nuxt)
+    const generator = new Generator(nuxt, builder)
+
+    return generator.generate()
+      .catch((e) => {
+        t.true(e.message === 'Not today!')
+      })
+  })
+  t.true(spies.log.calledWithMatch('DONE'))
+  t.true(spies.error.withArgs('Could not resolve routes').calledOnce)
 })
diff --git a/test/basic.generate.nosubfolders.test.js b/test/basic.generate.nosubfolders.test.js
deleted file mode 100644
index 5aeb01a16f..0000000000
--- a/test/basic.generate.nosubfolders.test.js
+++ /dev/null
@@ -1,138 +0,0 @@
-import test from 'ava'
-import { resolve } from 'path'
-import { existsSync } from 'fs'
-import http from 'http'
-import serveStatic from 'serve-static'
-import finalhandler from 'finalhandler'
-import rp from 'request-promise-native'
-import { Nuxt, Builder, Generator } from '..'
-
-const port = 4002
-const url = (route) => 'http://localhost:' + port + route
-
-let nuxt = null
-let server = null
-
-// Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
-  const rootDir = resolve(__dirname, 'fixtures/basic')
-  let config = require(resolve(rootDir, 'nuxt.config.js'))
-  config.rootDir = rootDir
-  config.dev = false
-  config.generate.subFolders = false
-
-  nuxt = new Nuxt(config)
-  const builder = new Builder(nuxt)
-  const generator = new Generator(nuxt, builder)
-  try {
-    await generator.generate() // throw an error (of /validate route)
-  } catch (err) {
-  }
-
-  const serve = serveStatic(resolve(__dirname, 'fixtures/basic/dist'), { extensions: ['html'] })
-  server = http.createServer((req, res) => {
-    serve(req, res, finalhandler(req, res))
-  })
-  server.listen(port)
-})
-
-test('Check ready hook called', async t => {
-  t.true(nuxt.__hook_called__)
-})
-
-test('/stateless', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/stateless'))
-  const html = window.document.body.innerHTML
-  t.true(html.includes('<h1>My component!</h1>'))
-})
-
-test('/css', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/css'))
-  const element = window.document.querySelector('.red')
-  t.not(element, null)
-  t.is(element.textContent, 'This is red')
-  t.is(element.className, 'red')
-  t.is(window.getComputedStyle(element).color, 'red')
-})
-
-test('/stateful', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/stateful'))
-  const html = window.document.body.innerHTML
-  t.true(html.includes('<div><p>The answer is 42</p></div>'))
-})
-
-test('/head', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/head'))
-  const html = window.document.body.innerHTML
-  const metas = window.document.getElementsByTagName('meta')
-  t.is(window.document.title, 'My title')
-  t.is(metas[0].getAttribute('content'), 'my meta')
-  t.true(html.includes('<div><h1>I can haz meta tags</h1></div>'))
-})
-
-test('/async-data', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/async-data'))
-  const html = window.document.body.innerHTML
-  t.true(html.includes('<p>Nuxt.js</p>'))
-})
-
-test('/users/1', async t => {
-  const html = await rp(url('/users/1'))
-  t.true(html.includes('<h1>User: 1</h1>'))
-  t.true(existsSync(resolve(__dirname, 'fixtures/basic/dist', 'users/1.html')))
-  t.false(existsSync(resolve(__dirname, 'fixtures/basic/dist', 'users/1/index.html')))
-})
-
-test('/users/2', async t => {
-  const html = await rp(url('/users/2'))
-  t.true(html.includes('<h1>User: 2</h1>'))
-})
-
-test('/users/3 (payload given)', async t => {
-  const html = await rp(url('/users/3'))
-  t.true(html.includes('<h1>User: 3000</h1>'))
-})
-
-test('/users/4 -> Not found', async t => {
-  try {
-    await rp(url('/users/4'))
-  } catch (error) {
-    t.true(error.statusCode === 404)
-    t.true(error.response.body.includes('Cannot GET /users/4'))
-  }
-})
-
-test('/validate should not be server-rendered', async t => {
-  const html = await rp(url('/validate'))
-  t.true(html.includes('<div id="__nuxt"></div>'))
-  t.true(html.includes('serverRendered:!1'))
-})
-
-test('/validate -> should display a 404', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/validate'))
-  const html = window.document.body.innerHTML
-  t.true(html.includes('This page could not be found'))
-})
-
-test('/validate?valid=true', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/validate?valid=true'))
-  const html = window.document.body.innerHTML
-  t.true(html.includes('I am valid</h1>'))
-})
-
-test('/redirect should not be server-rendered', async t => {
-  const html = await rp(url('/redirect'))
-  t.true(html.includes('<div id="__nuxt"></div>'))
-  t.true(html.includes('serverRendered:!1'))
-})
-
-test('/redirect -> check redirected source', async t => {
-  const window = await nuxt.renderAndGetWindow(url('/redirect'))
-  const html = window.document.body.innerHTML
-  t.true(html.includes('<h1>Index page</h1>'))
-})
-
-// Close server and ask nuxt to stop listening to file changes
-test.after('Closing server', t => {
-  server.close()
-})
diff --git a/test/basic.generate.test.js b/test/basic.generate.test.js
index 877cd1c52a..27f169b492 100644
--- a/test/basic.generate.test.js
+++ b/test/basic.generate.test.js
@@ -1,31 +1,39 @@
 import test from 'ava'
 import { resolve } from 'path'
 import { existsSync } from 'fs'
+import { remove } from 'fs-extra'
 import http from 'http'
 import serveStatic from 'serve-static'
 import finalhandler from 'finalhandler'
 import rp from 'request-promise-native'
+import { interceptLog, release } from './helpers/console'
 import { Nuxt, Builder, Generator } from '..'
 
 const port = 4002
 const url = (route) => 'http://localhost:' + port + route
+const rootDir = resolve(__dirname, 'fixtures/basic')
 
 let nuxt = null
 let server = null
+let generator = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
-  const rootDir = resolve(__dirname, 'fixtures/basic')
+test.serial('Init Nuxt.js', async t => {
   let config = require(resolve(rootDir, 'nuxt.config.js'))
   config.rootDir = rootDir
+  config.buildDir = '.nuxt-generate'
   config.dev = false
-  nuxt = new Nuxt(config)
-  const builder = new Builder(nuxt)
-  const generator = new Generator(nuxt, builder)
-  try {
-    await generator.generate() // throw an error (of /validate route)
-  } catch (err) {
-  }
+  config.build.stats = false
+
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    const builder = new Builder(nuxt)
+    generator = new Generator(nuxt, builder)
+
+    await generator.generate()
+  })
+  t.true(logSpy.calledWithMatch('DONE'))
+
   const serve = serveStatic(resolve(__dirname, 'fixtures/basic/dist'))
   server = http.createServer((req, res) => {
     serve(req, res, finalhandler(req, res))
@@ -33,17 +41,17 @@ test.before('Init Nuxt.js', async t => {
   server.listen(port)
 })
 
-test('Check ready hook called', async t => {
+test.serial('Check ready hook called', async t => {
   t.true(nuxt.__hook_called__)
 })
 
-test('/stateless', async t => {
+test.serial('/stateless', async t => {
   const window = await nuxt.renderAndGetWindow(url('/stateless'))
   const html = window.document.body.innerHTML
   t.true(html.includes('<h1>My component!</h1>'))
 })
 
-test('/css', async t => {
+test.serial('/css', async t => {
   const window = await nuxt.renderAndGetWindow(url('/css'))
   const element = window.document.querySelector('.red')
   t.not(element, null)
@@ -52,84 +60,106 @@ test('/css', async t => {
   t.is(window.getComputedStyle(element).color, 'red')
 })
 
-test('/stateful', async t => {
+test.serial('/stateful', async t => {
   const window = await nuxt.renderAndGetWindow(url('/stateful'))
   const html = window.document.body.innerHTML
   t.true(html.includes('<div><p>The answer is 42</p></div>'))
 })
 
-test('/head', async t => {
+test.serial('/head', async t => {
+  const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/head'))
   const html = window.document.body.innerHTML
   const metas = window.document.getElementsByTagName('meta')
   t.is(window.document.title, 'My title')
   t.is(metas[0].getAttribute('content'), 'my meta')
   t.true(html.includes('<div><h1>I can haz meta tags</h1></div>'))
+  release()
+  t.is(logSpy.getCall(0).args[0], 'Body script!')
 })
 
-test('/async-data', async t => {
+test.serial('/async-data', async t => {
   const window = await nuxt.renderAndGetWindow(url('/async-data'))
   const html = window.document.body.innerHTML
   t.true(html.includes('<p>Nuxt.js</p>'))
 })
 
-test('/users/1', async t => {
-  const html = await rp(url('/users/1'))
+test.serial('/users/1/index.html', async t => {
+  const html = await rp(url('/users/1/index.html'))
   t.true(html.includes('<h1>User: 1</h1>'))
   t.true(existsSync(resolve(__dirname, 'fixtures/basic/dist', 'users/1/index.html')))
   t.false(existsSync(resolve(__dirname, 'fixtures/basic/dist', 'users/1.html')))
 })
 
-test('/users/2', async t => {
+test.serial('/users/2', async t => {
   const html = await rp(url('/users/2'))
   t.true(html.includes('<h1>User: 2</h1>'))
 })
 
-test('/users/3 (payload given)', async t => {
+test.serial('/users/3 (payload given)', async t => {
   const html = await rp(url('/users/3'))
   t.true(html.includes('<h1>User: 3000</h1>'))
 })
 
-test('/users/4 -> Not found', async t => {
-  try {
-    await rp(url('/users/4'))
-  } catch (error) {
-    t.true(error.statusCode === 404)
-    t.true(error.response.body.includes('Cannot GET /users/4'))
-  }
+test.serial('/users/4 -> Not found', async t => {
+  const error = await t.throws(rp(url('/users/4')))
+  t.true(error.statusCode === 404)
+  t.true(error.response.body.includes('Cannot GET /users/4'))
 })
 
-test('/validate should not be server-rendered', async t => {
+test.serial('/validate should not be server-rendered', async t => {
   const html = await rp(url('/validate'))
   t.true(html.includes('<div id="__nuxt"></div>'))
   t.true(html.includes('serverRendered:!1'))
 })
 
-test('/validate -> should display a 404', async t => {
+test.serial('/validate -> should display a 404', async t => {
   const window = await nuxt.renderAndGetWindow(url('/validate'))
   const html = window.document.body.innerHTML
   t.true(html.includes('This page could not be found'))
 })
 
-test('/validate?valid=true', async t => {
+test.serial('/validate?valid=true', async t => {
   const window = await nuxt.renderAndGetWindow(url('/validate?valid=true'))
   const html = window.document.body.innerHTML
   t.true(html.includes('I am valid</h1>'))
 })
 
-test('/redirect should not be server-rendered', async t => {
+test.serial('/redirect should not be server-rendered', async t => {
   const html = await rp(url('/redirect'))
   t.true(html.includes('<div id="__nuxt"></div>'))
   t.true(html.includes('serverRendered:!1'))
 })
 
-test('/redirect -> check redirected source', async t => {
+test.serial('/redirect -> check redirected source', async t => {
   const window = await nuxt.renderAndGetWindow(url('/redirect'))
   const html = window.document.body.innerHTML
   t.true(html.includes('<h1>Index page</h1>'))
 })
 
-// Close server and ask nuxt to stop listening to file changes
-test.after('Closing server', t => {
-  server.close()
+test.serial('/users/1 not found', async t => {
+  await remove(resolve(rootDir, 'dist/users'))
+  const error = await t.throws(rp(url('/users/1')))
+  t.true(error.statusCode === 404)
+  t.true(error.response.body.includes('Cannot GET /users/1'))
+})
+
+test.serial('nuxt re-generating with no subfolders', async t => {
+  const logSpy = await interceptLog()
+  nuxt.options.generate.subFolders = false
+  await generator.generate()
+  release()
+  t.true(logSpy.calledWithMatch('DONE'))
+})
+
+test.serial('/users/1.html', async t => {
+  const html = await rp(url('/users/1.html'))
+  t.true(html.includes('<h1>User: 1</h1>'))
+  t.true(existsSync(resolve(__dirname, 'fixtures/basic/dist', 'users/1.html')))
+  t.false(existsSync(resolve(__dirname, 'fixtures/basic/dist', 'users/1/index.html')))
+})
+
+// Close server and ask nuxt to stop listening to file changes
+test.after.always('Closing server', async t => {
+  await server.close()
 })
diff --git a/test/basic.ssr.test.js b/test/basic.ssr.test.js
index 0e5a98b237..d023acaa8b 100755
--- a/test/basic.ssr.test.js
+++ b/test/basic.ssr.test.js
@@ -2,30 +2,38 @@ import test from 'ava'
 import { resolve } from 'path'
 import rp from 'request-promise-native'
 import { Nuxt, Builder } from '..'
-import { interceptLog, interceptError } from './helpers/console'
+import { interceptLog, interceptError, release } from './helpers/console'
 
-const port = 4003
+const port = 4004
 const url = (route) => 'http://localhost:' + port + route
 
 let nuxt = null
 
 // Init nuxt.js and create server listening on localhost:4003
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const options = {
     rootDir: resolve(__dirname, 'fixtures/basic'),
+    buildDir: '.nuxt-ssr',
     dev: false,
     head: {
       titleTemplate(titleChunk) {
         return titleChunk ? `${titleChunk} - Nuxt.js` : 'Nuxt.js'
       }
+    },
+    build: {
+      stats: false
     }
   }
 
-  await interceptLog('building nuxt', async () => {
+  const logSpy = await interceptLog(async () => {
     nuxt = new Nuxt(options)
-    await new Builder(nuxt).build()
-    await nuxt.listen(port, 'localhost')
+    const builder = await new Builder(nuxt)
+    await builder.build()
+    await nuxt.listen(port, '0.0.0.0')
   })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
 test('/stateless', async t => {
@@ -62,18 +70,19 @@ test('/store', async t => {
   t.true(html.includes('<p>1</p>'))
 })
 
-test('/head', async t => {
-  const logSpy = await interceptLog(async () => {
-    const window = await nuxt.renderAndGetWindow(url('/head'), { virtualConsole: false })
-    t.is(window.document.title, 'My title - Nuxt.js')
+test.serial('/head', async t => {
+  const logSpy = await interceptLog()
+  const window = await nuxt.renderAndGetWindow(url('/head'), { virtualConsole: false })
+  t.is(window.document.title, 'My title - Nuxt.js')
 
-    const html = window.document.body.innerHTML
-    t.true(html.includes('<div><h1>I can haz meta tags</h1></div>'))
-    t.true(html.includes('<script data-n-head="true" src="/body.js" data-body="true">'))
+  const html = window.document.body.innerHTML
+  t.true(html.includes('<div><h1>I can haz meta tags</h1></div>'))
+  t.true(html.includes('<script data-n-head="true" src="/body.js" data-body="true">'))
+
+  const metas = window.document.getElementsByTagName('meta')
+  t.is(metas[0].getAttribute('content'), 'my meta')
+  release()
 
-    const metas = window.document.getElementsByTagName('meta')
-    t.is(metas[0].getAttribute('content'), 'my meta')
-  })
   t.true(logSpy.calledOnce)
   t.is(logSpy.args[0][0], 'Body script!')
 })
@@ -145,12 +154,12 @@ test('/error', async t => {
   t.true(err.message.includes('Error mouahahah'))
 })
 
-test('/error status code', async t => {
-  const errorSpy = await interceptError(async () => {
-    const err = await t.throws(rp(url('/error')))
-    t.true(err.statusCode === 500)
-    t.true(err.response.body.includes('An error occurred in the application and your page could not be served'))
-  })
+test.serial('/error status code', async t => {
+  const errorSpy = await interceptError()
+  const err = await t.throws(rp(url('/error')))
+  t.true(err.statusCode === 500)
+  t.true(err.response.body.includes('An error occurred in the application and your page could not be served'))
+  release()
   t.true(errorSpy.calledOnce)
   t.true(errorSpy.args[0][0].message.includes('Error mouahahah'))
 })
@@ -163,29 +172,25 @@ test('/error2', async t => {
 })
 
 test('/error2 status code', async t => {
-  try {
-    await rp(url('/error2'))
-  } catch (err) {
-    t.is(err.statusCode, 500)
-    t.true(err.response.body.includes('Custom error'))
-  }
+  const error = await t.throws(rp(url('/error2')))
+  t.is(error.statusCode, 500)
+  t.true(error.response.body.includes('Custom error'))
 })
 
-test('/error-midd', async t => {
-  const errorSpy = await interceptError(async () => {
-    const err = await t.throws(rp(url('/error-midd')))
-
-    t.is(err.statusCode, 505)
-    t.true(err.response.body.includes('Middleware Error'))
-  })
+test.serial('/error-midd', async t => {
+  const errorSpy = await interceptError()
+  const err = await t.throws(rp(url('/error-midd')))
+  t.is(err.statusCode, 505)
+  t.true(err.response.body.includes('Middleware Error'))
+  release()
   // Don't display error since redirect returns a noopApp
   t.true(errorSpy.notCalled)
 })
 
-test('/redirect2', async t => {
-  const errorSpy = await interceptError(async () => {
-    await rp(url('/redirect2')) // Should not console.error
-  })
+test.serial('/redirect2', async t => {
+  const errorSpy = await interceptError()
+  await rp(url('/redirect2')) // Should not console.error
+  release()
   // Don't display error since redirect returns a noopApp
   t.true(errorSpy.notCalled)
 })
@@ -202,16 +207,12 @@ test('/no-ssr (client-side)', async t => {
 })
 
 test('ETag Header', async t => {
-  const errorSpy = await interceptError(async () => {
-    const { headers: { etag } } = await rp(url('/stateless'), { resolveWithFullResponse: true })
-    // Validate etag
-    t.regex(etag, /W\/".*"$/)
-    // Verify functionality
-    const error = await t.throws(rp(url('/stateless'), { headers: { 'If-None-Match': etag } }))
-    t.is(error.statusCode, 304)
-  })
-  t.true(errorSpy.calledOnce)
-  t.true(errorSpy.args[0][0].includes('TypeError: Cannot read property \'split\' of undefined'))
+  const { headers: { etag } } = await rp(url('/stateless'), { resolveWithFullResponse: true })
+  // Validate etag
+  t.regex(etag, /W\/".*"$/)
+  // Verify functionality
+  const error = await t.throws(rp(url('/stateless'), { headers: { 'If-None-Match': etag } }))
+  t.is(error.statusCode, 304)
 })
 
 test('/_nuxt/server-bundle.json should return 404', async t => {
@@ -226,7 +227,6 @@ test('/_nuxt/ should return 404', async t => {
 
 test('/meta', async t => {
   const { html } = await nuxt.renderRoute('/meta')
-
   t.true(html.includes('"meta":[{"works":true}]'))
 })
 
@@ -258,6 +258,6 @@ test('/js-link', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', async t => {
+test.after.always('Closing server and nuxt.js', async t => {
   await nuxt.close()
 })
diff --git a/test/children.patch.test.js b/test/children.patch.test.js
index 46bb123526..a83c36de72 100644
--- a/test/children.patch.test.js
+++ b/test/children.patch.test.js
@@ -2,34 +2,45 @@ import test from 'ava'
 import { resolve } from 'path'
 import { Nuxt, Builder, Utils } from '..'
 import * as browser from './helpers/browser'
+import { interceptLog } from './helpers/console'
 
-const port = 4005
+const port = 4014
 const url = (route) => 'http://localhost:' + port + route
 
 let nuxt = null
+let page
+const dates = {}
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const options = {
     rootDir: resolve(__dirname, 'fixtures/children'),
-    dev: false
+    buildDir: '.nuxt-patch',
+    dev: false,
+    build: {
+      stats: false
+    }
   }
-  nuxt = new Nuxt(options)
-  await new Builder(nuxt).build()
 
-  await nuxt.listen(port, 'localhost')
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(options)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
-test.before('Start browser', async t => {
+
+test.serial('Start browser', async t => {
+  t.plan(0) // suppress 'no assertions' warning
   await browser.start({
     // slowMo: 50,
     // headless: false
   })
 })
 
-let page
-const dates = {}
-
-test('Loading /patch and keep ', async t => {
+test.serial('Loading /patch and keep ', async t => {
   page = await browser.page(url('/patch'))
 
   const h1 = await page.$text('h1')
@@ -39,7 +50,7 @@ test('Loading /patch and keep ', async t => {
   dates.patch = await page.$text('[data-date-patch]')
 })
 
-test('Navigate to /patch/1', async t => {
+test.serial('Navigate to /patch/1', async t => {
   const { hook } = await page.nuxt.navigate('/patch/1', false)
   const loading = await page.nuxt.loadingData()
   t.is(loading.show, true)
@@ -52,7 +63,7 @@ test('Navigate to /patch/1', async t => {
   t.is(dates.patch, await page.$text('[data-date-patch]'))
 })
 
-test('Navigate to /patch/2', async t => {
+test.serial('Navigate to /patch/2', async t => {
   await page.nuxt.navigate('/patch/2')
   const date = await page.$text('[data-date-id]')
 
@@ -62,19 +73,19 @@ test('Navigate to /patch/2', async t => {
   dates.id = date
 })
 
-test('Navigate to /patch/2?test=true', async t => {
+test.serial('Navigate to /patch/2?test=true', async t => {
   await page.nuxt.navigate('/patch/2?test=true')
   t.is(dates.patch, await page.$text('[data-date-patch]'))
   t.is(dates.id, await page.$text('[data-date-id]'))
 })
 
-test('Navigate to /patch/2#test', async t => {
+test.serial('Navigate to /patch/2#test', async t => {
   await page.nuxt.navigate('/patch/2#test')
   t.is(dates.patch, await page.$text('[data-date-patch]'))
   t.is(dates.id, await page.$text('[data-date-id]'))
 })
 
-test('Navigate to /patch/2/child', async t => {
+test.serial('Navigate to /patch/2/child', async t => {
   await page.nuxt.navigate('/patch/2/child')
   dates.child = await page.$text('[data-date-child]')
   dates.slug = await page.$text('[data-date-child-slug]')
@@ -85,7 +96,7 @@ test('Navigate to /patch/2/child', async t => {
   t.true(+dates.slug > +dates.child)
 })
 
-test('Navigate to /patch/2/child/1', async t => {
+test.serial('Navigate to /patch/2/child/1', async t => {
   await page.nuxt.navigate('/patch/2/child/1')
   const date = await page.$text('[data-date-child-slug]')
 
@@ -96,7 +107,7 @@ test('Navigate to /patch/2/child/1', async t => {
   dates.slug = date
 })
 
-test('Navigate to /patch/2/child/1?foo=bar', async t => {
+test.serial('Navigate to /patch/2/child/1?foo=bar', async t => {
   await page.nuxt.navigate('/patch/2/child/1?foo=bar')
 
   t.is(dates.patch, await page.$text('[data-date-patch]'))
@@ -105,7 +116,7 @@ test('Navigate to /patch/2/child/1?foo=bar', async t => {
   t.is(dates.slug, await page.$text('[data-date-child-slug]'))
 })
 
-test('Search a country', async t => {
+test.serial('Search a country', async t => {
   const countries = await page.$$text('[data-test-search-result]')
   t.is(countries.length, 5)
 
@@ -125,10 +136,11 @@ test('Search a country', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
-test.after('Stop browser', async t => {
+
+test.after.always('Stop browser', async t => {
   await page.close()
   await browser.stop()
 })
diff --git a/test/children.test.js b/test/children.test.js
index 25fddc71a9..165ee19b09 100644
--- a/test/children.test.js
+++ b/test/children.test.js
@@ -1,22 +1,31 @@
 import test from 'ava'
 import { resolve } from 'path'
 import { Nuxt, Builder } from '..'
+import { interceptLog } from './helpers/console'
 
-const port = 4004
+const port = 4013
 // const url = (route) => 'http://localhost:' + port + route
 
 let nuxt = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const options = {
     rootDir: resolve(__dirname, 'fixtures/children'),
-    dev: false
+    dev: false,
+    build: {
+      stats: false
+    }
   }
-  nuxt = new Nuxt(options)
-  await new Builder(nuxt).build()
 
-  await nuxt.listen(port, 'localhost')
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(options)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
 test('/parent', async t => {
@@ -54,6 +63,6 @@ test('/parent/validate-child?key=12345', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/cli.test.js b/test/cli.test.js
index 4e47ba0227..0182d41d07 100644
--- a/test/cli.test.js
+++ b/test/cli.test.js
@@ -11,7 +11,7 @@ const rootDir = resolve(__dirname, 'fixtures/basic')
 const port = 4011
 const url = (route) => 'http://localhost:' + port + route
 
-test('bin/nuxt-build', async t => {
+test.serial('bin/nuxt-build', async t => {
   const binBuild = resolve(__dirname, '..', 'bin', 'nuxt-build')
 
   const { stdout, stderr } = await execify(`node ${binBuild} ${rootDir}`)
@@ -20,7 +20,7 @@ test('bin/nuxt-build', async t => {
   t.true(stderr.includes('Building done'))
 })
 
-test('bin/nuxt-start', async t => {
+test.serial('bin/nuxt-start', async t => {
   const binStart = resolve(__dirname, '..', 'bin', 'nuxt-start')
 
   let stdout = ''
@@ -79,7 +79,7 @@ test('bin/nuxt-start', async t => {
   t.is(exitCode, null)
 })
 
-test('bin/nuxt-generate', async t => {
+test.serial('bin/nuxt-generate', async t => {
   const binGenerate = resolve(__dirname, '..', 'bin', 'nuxt-generate')
 
   const { stdout, stderr } = await execify(`node ${binGenerate} ${rootDir}`)
diff --git a/test/debug.test.js b/test/debug.test.js
index e198c9642e..3a1ccf3ea6 100644
--- a/test/debug.test.js
+++ b/test/debug.test.js
@@ -2,6 +2,7 @@ import test from 'ava'
 import { resolve } from 'path'
 import rp from 'request-promise-native'
 import { Nuxt, Builder } from '..'
+import { interceptLog, interceptError, release } from './helpers/console'
 
 const port = 4009
 const url = (route) => 'http://localhost:' + port + route
@@ -9,60 +10,87 @@ const url = (route) => 'http://localhost:' + port + route
 let nuxt = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const rootDir = resolve(__dirname, 'fixtures/debug')
   let config = require(resolve(rootDir, 'nuxt.config.js'))
   config.rootDir = rootDir
-  config.dev = true // Needed for _open middleware
-  nuxt = new Nuxt(config)
-  await new Builder(nuxt).build()
 
-  await nuxt.listen(port, 'localhost')
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
-test('/test/_open (open-in-editor)', async t => {
+test.serial('/test/_open (open-in-editor)', async t => {
+  const logSpy = await interceptLog()
   const { body } = await rp(url('/test/_open?file=pages/index.vue'), { resolveWithFullResponse: true })
   t.is(body, 'opened in editor!')
+  release()
+  t.is(logSpy.getCall(0).args[0], '[open in editor]')
+  t.true(logSpy.calledOnce)
 })
 
-test('/test/_open should return error (open-in-editor)', async t => {
+test.serial('/test/_open should return error (open-in-editor)', async t => {
+  const logSpy = await interceptLog()
   const { body } = await rp(url('/test/_open?file='), { resolveWithFullResponse: true })
   t.is(body, 'File is not specified')
+  release()
+  t.is(logSpy.getCall(0).args[0], '[open in editor]')
+  t.true(logSpy.calledOnce)
 })
 
-test('/test/error should return error stack trace (Youch)', async t => {
+test.serial('/test/error should return error stack trace (Youch)', async t => {
+  const errorSpy = await interceptError()
   const { response, error } = await t.throws(nuxt.renderAndGetWindow(url('/test/error')))
   t.is(response.statusCode, 500)
   t.is(response.statusMessage, 'NuxtServerError')
   t.true(error.includes('test youch !'))
   t.true(error.includes('<div class="error-frames">'))
+  release()
+  t.true(errorSpy.calledTwice)
+  t.true(errorSpy.getCall(0).args[0].includes('test youch !'))
+  t.true(errorSpy.getCall(1).args[0].message.includes('test youch !'))
 })
 
-test('/test/error no source-map (Youch)', async t => {
+test.serial('/test/error no source-map (Youch)', async t => {
   const sourceMaps = nuxt.renderer.resources.serverBundle.maps
   nuxt.renderer.resources.serverBundle.maps = {}
 
+  const errorSpy = await interceptError()
   const { response, error } = await t.throws(nuxt.renderAndGetWindow(url('/test/error')))
   t.is(response.statusCode, 500)
   t.is(response.statusMessage, 'NuxtServerError')
   t.true(error.includes('test youch !'))
   t.true(error.includes('<div class="error-frames">'))
+  release()
+  t.true(errorSpy.calledTwice)
+  t.true(errorSpy.getCall(0).args[0].includes('test youch !'))
+  t.true(errorSpy.getCall(1).args[0].message.includes('test youch !'))
 
   nuxt.renderer.resources.serverBundle.maps = sourceMaps
 })
 
-test('/test/error should return json format error (Youch)', async t => {
+test.serial('/test/error should return json format error (Youch)', async t => {
   const opts = {
     headers: {
       'accept': 'application/json'
     },
     resolveWithFullResponse: true
   }
+  const errorSpy = await interceptError()
   const { response: { headers } } = await t.throws(rp(url('/test/error'), opts))
   t.is(headers['content-type'], 'text/json; charset=utf-8')
+  release()
+  t.true(errorSpy.calledTwice)
+  t.true(errorSpy.getCall(0).args[0].includes('test youch !'))
+  t.true(errorSpy.getCall(1).args[0].message.includes('test youch !'))
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/deprecate.test.js b/test/deprecate.test.js
index e3dd43addc..835f33d6d3 100755
--- a/test/deprecate.test.js
+++ b/test/deprecate.test.js
@@ -1,50 +1,52 @@
 import test from 'ava'
-import { interceptWarn, release } from './helpers/console'
 import { resolve } from 'path'
 import rp from 'request-promise-native'
 import { Nuxt, Builder } from '..'
+import { intercept, interceptWarn, release } from './helpers/console'
 
 const port = 4010
 const url = (route) => 'http://localhost:' + port + route
 
 let nuxt = null
 let builder = null
-let buildLog = null
+let buildSpies = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const rootDir = resolve(__dirname, 'fixtures/deprecate')
   let config = require(resolve(rootDir, 'nuxt.config.js'))
   config.rootDir = rootDir
   config.dev = false
-  nuxt = new Nuxt(config)
-  builder = new Builder(nuxt)
 
-  buildLog = await interceptWarn()
-  await builder.build()
-  release()
+  buildSpies = await intercept(async () => {
+    nuxt = new Nuxt(config)
+    builder = await new Builder(nuxt)
+    await builder.build()
+    await nuxt.listen(port, 'localhost')
+  })
 
-  await nuxt.listen(port, 'localhost')
+  t.true(buildSpies.log.calledWithMatch('DONE'))
+  t.true(buildSpies.log.calledWithMatch('OPEN'))
 })
 
-test('Deprecated: context.isServer and context.isClient', async t => {
-  const logSpy = await interceptWarn()
+test.serial('Deprecated: context.isServer and context.isClient', async t => {
+  const warnSpy = await interceptWarn()
   await rp(url('/'))
-  t.true(logSpy.calledWith('context.isServer has been deprecated, please use process.server instead.'))
-  t.true(logSpy.calledWith('context.isClient has been deprecated, please use process.client instead.'))
-  t.true(logSpy.calledTwice)
+  t.true(warnSpy.calledWith('context.isServer has been deprecated, please use process.server instead.'))
+  t.true(warnSpy.calledWith('context.isClient has been deprecated, please use process.client instead.'))
+  t.true(warnSpy.calledTwice)
   release()
 })
 
-test('Deprecated: dev in build.extend()', async t => {
-  t.true(buildLog.withArgs('dev has been deprecated in build.extend(), please use isDev').calledTwice)
+test.serial('Deprecated: dev in build.extend()', async t => {
+  t.true(buildSpies.warn.withArgs('dev has been deprecated in build.extend(), please use isDev').calledTwice)
 })
 
-test('Deprecated: nuxt.plugin()', async t => {
+test.serial('Deprecated: nuxt.plugin()', async t => {
   t.true(nuxt.__builder_plugin)
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/dll.test.js b/test/dll.test.js
index cab26dc860..c114855f37 100644
--- a/test/dll.test.js
+++ b/test/dll.test.js
@@ -6,7 +6,7 @@ import { Nuxt, Builder } from '..'
 import { interceptLog, release } from './helpers/console'
 
 const readFile = promisify(fs.readFile)
-const rootDir = resolve(__dirname, './fixtures/dll')
+const rootDir = resolve(__dirname, 'fixtures/dll')
 const dllDir = resolve(rootDir, '.cache/client-dll')
 
 const checkCache = (lib) => {
@@ -19,12 +19,16 @@ const checkCache = (lib) => {
 
 let nuxt
 
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   let config = require(resolve(rootDir, 'nuxt.config.js'))
   config.rootDir = rootDir
   config.dev = true
-  nuxt = new Nuxt(config)
-  await new Builder(nuxt).build()
+
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    await new Builder(nuxt).build()
+  })
+  t.true(logSpy.calledWithMatch('DONE'))
 })
 
 test('Check vue cache', checkCache('vue'))
@@ -41,6 +45,6 @@ test('Build with DllReferencePlugin', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing nuxt.js', t => {
+test.after.always('Closing nuxt.js', t => {
   nuxt.close()
 })
diff --git a/test/dynamic-routes.test.js b/test/dynamic-routes.test.js
index c705f5eb62..bfe522f72a 100644
--- a/test/dynamic-routes.test.js
+++ b/test/dynamic-routes.test.js
@@ -3,15 +3,24 @@ import { resolve } from 'path'
 import fs from 'fs'
 import { Nuxt, Builder } from '..'
 import { promisify } from 'util'
+import { interceptLog } from './helpers/console'
 
 const readFile = promisify(fs.readFile)
 
-test.before('Init Nuxt.js', async t => {
-  const nuxt = new Nuxt({
+test.serial('Init Nuxt.js', async t => {
+  const config = {
     rootDir: resolve(__dirname, 'fixtures/dynamic-routes'),
-    dev: false
+    dev: false,
+    build: {
+      stats: false
+    }
+  }
+
+  const logSpy = await interceptLog(async () => {
+    const nuxt = new Nuxt(config)
+    await new Builder(nuxt).build()
   })
-  await new Builder(nuxt).build()
+  t.true(logSpy.calledWithMatch('DONE'))
 })
 
 test('Check .nuxt/router.js', t => {
diff --git a/test/error.test.js b/test/error.test.js
index 7a81f2d96a..6621818c9d 100644
--- a/test/error.test.js
+++ b/test/error.test.js
@@ -2,6 +2,7 @@ import test from 'ava'
 import { resolve } from 'path'
 import rp from 'request-promise-native'
 import { Nuxt, Builder } from '..'
+import { interceptLog, interceptError, release } from './helpers/console'
 
 const port = 4005
 const url = (route) => 'http://localhost:' + port + route
@@ -9,48 +10,61 @@ const url = (route) => 'http://localhost:' + port + route
 let nuxt = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const options = {
     rootDir: resolve(__dirname, 'fixtures/error'),
-    dev: false
+    dev: false,
+    build: {
+      stats: false
+    }
   }
-  nuxt = new Nuxt(options)
-  await new Builder(nuxt).build()
 
-  await nuxt.listen(port, 'localhost')
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(options)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
-test('/ should display an error', async t => {
-  try {
-    await nuxt.renderRoute('/')
-  } catch (e) {
-    t.true(e.message.includes('not_defined is not defined'))
-  }
+test.serial('/ should display an error', async t => {
+  const error = await t.throws(nuxt.renderRoute('/'))
+  t.true(error.message.includes('not_defined is not defined'))
 })
 
-test('/404 should display an error too', async t => {
+test.serial('/404 should display an error too', async t => {
   let { error } = await nuxt.renderRoute('/404')
   t.true(error.message.includes('This page could not be found'))
 })
 
-test('/ with renderAndGetWindow()', async t => {
+test.serial('/ with renderAndGetWindow()', async t => {
+  const errorSpy = await interceptError()
   const err = await t.throws(nuxt.renderAndGetWindow(url('/')))
   t.is(err.response.statusCode, 500)
   t.is(err.response.statusMessage, 'NuxtServerError')
+  release()
+  t.true(errorSpy.calledOnce)
+  t.true(errorSpy.getCall(0).args[0].message.includes('render function or template not defined in component: anonymous'))
 })
 
-test('/ with text/json content', async t => {
+test.serial('/ with text/json content', async t => {
   const opts = {
     headers: {
       'accept': 'application/json'
     },
     resolveWithFullResponse: true
   }
+  const errorSpy = await interceptError()
   const { response: { headers } } = await t.throws(rp(url('/'), opts))
   t.is(headers['content-type'], 'text/json; charset=utf-8')
+  release()
+  t.true(errorSpy.calledOnce)
+  t.true(errorSpy.getCall(0).args[0].message.includes('render function or template not defined in component: anonymous'))
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/express.test.js b/test/express.test.js
index 676e931ee3..62b74149a0 100644
--- a/test/express.test.js
+++ b/test/express.test.js
@@ -3,6 +3,7 @@ import { resolve } from 'path'
 import { Nuxt, Builder } from '..'
 import express from 'express'
 import rp from 'request-promise-native'
+import { interceptLog } from './helpers/console'
 
 const port = 4000
 const url = (route) => 'http://localhost:' + port + route
@@ -11,17 +12,21 @@ let nuxt
 let app
 
 // Init nuxt.js and create express server
-test.before('Init Nuxt.js', async t => {
-  const options = {
+test.serial('Init Nuxt.js', async t => {
+  const config = {
     rootDir: resolve(__dirname, 'fixtures/basic'),
-    dev: false
+    buildDir: '.nuxt-express',
+    dev: false,
+    build: {
+      stats: false
+    }
   }
 
-  // Create nuxt instace
-  nuxt = new Nuxt(options)
-
-  // Build
-  await new Builder(nuxt).build()
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    await new Builder(nuxt).build()
+  })
+  t.true(logSpy.calledWithMatch('DONE'))
 
   // Create express app
   app = express()
diff --git a/test/fixtures/debug/nuxt.config.js b/test/fixtures/debug/nuxt.config.js
index 2e05a7cd6e..8de5df3d80 100644
--- a/test/fixtures/debug/nuxt.config.js
+++ b/test/fixtures/debug/nuxt.config.js
@@ -2,9 +2,13 @@ module.exports = {
   router: {
     base: '/test/'
   },
+  dev: true, // Needed for _open middleware
   debug: true,
   editor: {
     cmd: 'echo',
     pattern: ''
+  },
+  build: {
+    stats: false
   }
 }
diff --git a/test/fixtures/deprecate/nuxt.config.js b/test/fixtures/deprecate/nuxt.config.js
index 2fc7d1f9ba..94975ec291 100755
--- a/test/fixtures/deprecate/nuxt.config.js
+++ b/test/fixtures/deprecate/nuxt.config.js
@@ -3,6 +3,7 @@ module.exports = {
     '~/modules/hooks'
   ],
   build: {
+    stats: false,
     extend(config, options) {
       if (options.dev) {
         // Please use isDev instead of dev
diff --git a/test/fixtures/dll/nuxt.config.js b/test/fixtures/dll/nuxt.config.js
index d2f540265b..455b772a14 100644
--- a/test/fixtures/dll/nuxt.config.js
+++ b/test/fixtures/dll/nuxt.config.js
@@ -1,5 +1,6 @@
 module.exports = {
   build: {
+    stats: false,
     dll: true,
     extend(config, options) {
       if (options.isClient) {
diff --git a/test/fixtures/module/nuxt.config.js b/test/fixtures/module/nuxt.config.js
index 60ff0fecee..52b8aad778 100755
--- a/test/fixtures/module/nuxt.config.js
+++ b/test/fixtures/module/nuxt.config.js
@@ -28,5 +28,8 @@ module.exports = {
         handler: '~/modules/middleware/use-middleware'
       })
     })
+  },
+  build: {
+    stats: false
   }
 }
diff --git a/test/fixtures/spa/nuxt.config.js b/test/fixtures/spa/nuxt.config.js
index bcbf687d27..79358e6611 100644
--- a/test/fixtures/spa/nuxt.config.js
+++ b/test/fixtures/spa/nuxt.config.js
@@ -1,6 +1,8 @@
 module.exports = {
-  rootDir: __dirname,
   mode: 'spa',
   dev: false,
-  transition: false
+  transition: false,
+  build: {
+    stats: false
+  }
 }
diff --git a/test/fixtures/ssr/nuxt.config.js b/test/fixtures/ssr/nuxt.config.js
new file mode 100644
index 0000000000..20d8e8a969
--- /dev/null
+++ b/test/fixtures/ssr/nuxt.config.js
@@ -0,0 +1,10 @@
+module.exports = {
+  dev: false,
+  render: {
+    resourceHints: false
+  },
+  build: {
+    stats: false,
+    extractCSS: true
+  }
+}
diff --git a/test/fixtures/with-config/nuxt.config.js b/test/fixtures/with-config/nuxt.config.js
index 37db356a99..523a672110 100644
--- a/test/fixtures/with-config/nuxt.config.js
+++ b/test/fixtures/with-config/nuxt.config.js
@@ -42,6 +42,7 @@ module.exports = {
     }
   },
   build: {
+    stats: false,
     publicPath: '/orion/',
     analyze: {
       analyzerMode: 'disabled',
diff --git a/test/helpers/console.js b/test/helpers/console.js
index 2b59e2511d..036883e8b1 100644
--- a/test/helpers/console.js
+++ b/test/helpers/console.js
@@ -20,6 +20,12 @@ export function release() {
   if (context.error) {
     console.error = context.error // eslint-disable-line no-console
   }
+  if (context.stdout) {
+    process.stdout.write = context.stdout
+  }
+  if (context.stderr) {
+    process.stderr.write = context.stderr
+  }
 
   context = null
 }
@@ -68,18 +74,32 @@ export async function intercept(levels, msg, cb) {
     spies.error = console.error = sinon.spy() // eslint-disable-line no-console
   }
 
+  if (levels && levels.stdout) {
+    context.stdout = process.stdout.write
+    spies.stdout = process.stdout.write = sinon.spy()
+  }
+
+  if (levels && levels.stderr) {
+    context.stdout = process.stderr.write
+    spies.stdout = process.stderr.write = sinon.spy()
+  }
+
   if (cb) {
     if (msg) {
-      process.stdout.write(`  ${msg}`)
+      if (context.stdout) {
+        context.stdout(`  ${msg}`)
+      } else {
+        process.stdout.write(`  ${msg}`)
+      }
     }
 
     await cb()
 
+    release()
+
     if (msg) {
       process.stdout.write('\n')
     }
-
-    release()
   }
 
   return spies
@@ -104,3 +124,13 @@ export async function interceptError(msg, cb) {
   const { error } = await intercept({ error: true }, msg, cb)
   return error
 }
+
+export async function interceptStdout(msg, cb) {
+  const { stderr } = await intercept({ stdout: true }, msg, cb)
+  return stderr
+}
+
+export async function interceptStderr(msg, cb) {
+  const { stderr } = await intercept({ stderr: true }, msg, cb)
+  return stderr
+}
diff --git a/test/index.test.js b/test/index.test.js
index 03632bdcb0..bc706544e0 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -6,7 +6,7 @@ test('Nuxt.js Class', t => {
   t.is(typeof Nuxt, 'function')
 })
 
-test.serial('Nuxt.js Instance', async t => {
+test('Nuxt.js Instance', async t => {
   const nuxt = new Nuxt({
     rootDir: resolve(__dirname, 'fixtures', 'empty')
   })
@@ -17,7 +17,7 @@ test.serial('Nuxt.js Instance', async t => {
   t.is(nuxt.initialized, true)
 })
 
-test.serial('Fail to build when no pages/ directory but is in the parent', t => {
+test('Fail to build when no pages/ directory but is in the parent', t => {
   const nuxt = new Nuxt({
     dev: false,
     rootDir: resolve(__dirname, 'fixtures', 'empty', 'pages')
@@ -29,7 +29,7 @@ test.serial('Fail to build when no pages/ directory but is in the parent', t =>
   })
 })
 
-test.serial('Fail to build when no pages/ directory', t => {
+test('Fail to build when no pages/ directory', t => {
   const nuxt = new Nuxt({
     dev: false,
     rootDir: resolve(__dirname)
diff --git a/test/module.test.js b/test/module.test.js
index 7cc7d8b6ac..7fd46e7c98 100755
--- a/test/module.test.js
+++ b/test/module.test.js
@@ -2,60 +2,62 @@ import test from 'ava'
 import { resolve, normalize } from 'path'
 import rp from 'request-promise-native'
 import { Nuxt, Builder } from '..'
-import { interceptError, release } from './helpers/console'
+import { intercept } from './helpers/console'
 
 const port = 4006
 const url = (route) => 'http://localhost:' + port + route
 
 let nuxt = null
 let builder = null
-let builtErr = null
+let buildSpies = null
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
+test.serial('Init Nuxt.js', async t => {
   const rootDir = resolve(__dirname, 'fixtures/module')
-  let config = require(resolve(rootDir, 'nuxt.config.js'))
+  const config = require(resolve(rootDir, 'nuxt.config.js'))
   config.rootDir = rootDir
   config.dev = false
   nuxt = new Nuxt(config)
   builder = new Builder(nuxt)
 
-  builtErr = await interceptError()
-  await builder.build()
-  release()
+  buildSpies = await intercept({ log: true, error: true }, async () => {
+    await builder.build()
+    await nuxt.listen(port, 'localhost')
+  })
 
-  await nuxt.listen(port, 'localhost')
+  t.true(buildSpies.log.calledWithMatch('DONE'))
+  t.true(buildSpies.log.calledWithMatch('OPEN'))
 })
 
-test('Vendor', async t => {
+test.serial('Vendor', async t => {
   t.true(nuxt.options.build.vendor.indexOf('lodash') !== -1, 'lodash added to config')
 })
 
-test('Plugin', async t => {
+test.serial('Plugin', async t => {
   t.true(normalize(nuxt.options.plugins[0].src)
     .includes(normalize('fixtures/module/.nuxt/basic.reverse.')), 'plugin added to config')
   const { html } = await nuxt.renderRoute('/')
   t.true(html.includes('<h1>TXUN</h1>'), 'plugin works')
 })
 
-test('Middleware', async t => {
-  let response = await rp(url('/api'))
-  t.is(response, 'It works!', '/api response is correct')
-})
-
-test('Hooks', async t => {
+test.serial('Hooks', async t => {
   t.is(nuxt.__module_hook, 1)
   t.is(nuxt.__renderer_hook, 2)
   t.is(nuxt.__builder_hook, 3)
 })
 
-test('Hooks - Functional', async t => {
+test.serial('Hooks - Functional', async t => {
   t.true(nuxt.__ready_called__)
   t.true(builder.__build_done__)
 })
 
-test('Hooks - Error', async t => {
-  t.true(builtErr.calledWithMatch(/build:extendRoutes/))
+test.serial('Hooks - Error', async t => {
+  t.true(buildSpies.error.calledWithMatch(/build:extendRoutes/))
+})
+
+test('Middleware', async t => {
+  let response = await rp(url('/api'))
+  t.is(response, 'It works!', '/api response is correct')
 })
 
 test('Hooks - Use external middleware before render', async t => {
@@ -64,6 +66,6 @@ test('Hooks - Use external middleware before render', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/spa.test.js b/test/spa.test.js
index ab9b66bf5d..41b179020b 100755
--- a/test/spa.test.js
+++ b/test/spa.test.js
@@ -1,10 +1,11 @@
 import test from 'ava'
+import { resolve } from 'path'
 import { Nuxt, Builder } from '..'
 import { interceptLog, release } from './helpers/console'
 
 let nuxt = null
 
-const port = 4004
+const port = 4012
 const url = (route) => 'http://localhost:' + port + route
 
 const renderRoute = async _url => {
@@ -15,28 +16,49 @@ const renderRoute = async _url => {
 }
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
-  nuxt = new Nuxt(require('./fixtures/spa/nuxt.config'))
-  await new Builder(nuxt).build()
-  await nuxt.listen(port, 'localhost')
+test.serial('Init Nuxt.js', async t => {
+  const rootDir = resolve(__dirname, 'fixtures/spa')
+  const config = require(resolve(rootDir, 'nuxt.config.js'))
+  config.rootDir = rootDir
+
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
-test('/ (basic spa)', async t => {
+test.serial('/ (basic spa)', async t => {
+  const logSpy = await interceptLog()
   const { html } = await renderRoute('/')
   t.true(html.includes('Hello SPA!'))
+  release()
+  t.true(logSpy.withArgs('created').notCalled)
+  t.true(logSpy.withArgs('mounted').calledOnce)
 })
 
-test('/custom (custom layout)', async t => {
+test.serial('/custom (custom layout)', async t => {
+  const logSpy = await interceptLog()
   const { html } = await renderRoute('/custom')
   t.true(html.includes('Custom layout'))
+  release()
+  t.true(logSpy.withArgs('created').calledOnce)
+  t.true(logSpy.withArgs('mounted').calledOnce)
 })
 
-test('/custom (not default layout)', async t => {
+test.serial('/custom (not default layout)', async t => {
+  const logSpy = await interceptLog()
   const { head } = await renderRoute('/custom')
   t.false(head.includes('src="/_nuxt/layouts/default.'))
+  release()
+  t.true(logSpy.withArgs('created').calledOnce)
+  t.true(logSpy.withArgs('mounted').calledOnce)
 })
 
-test('/custom (call mounted and created once)', async t => {
+test.serial('/custom (call mounted and created once)', async t => {
   const logSpy = await interceptLog()
   await renderRoute('/custom')
   release()
@@ -51,6 +73,6 @@ test('/_nuxt/ (access publicPath in spa mode)', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/ssr.test.js b/test/ssr.test.js
index 267aaba508..99735578b4 100755
--- a/test/ssr.test.js
+++ b/test/ssr.test.js
@@ -3,6 +3,7 @@ import { resolve } from 'path'
 import { Nuxt, Builder, Utils } from '..'
 import { uniq } from 'lodash'
 import rp from 'request-promise-native'
+import { interceptLog } from './helpers/console'
 
 const port = 4008
 let nuxt = null
@@ -17,20 +18,19 @@ const url = (route) => 'http://localhost:' + port + route
 const isWindows = /^win/.test(process.platform)
 
 // Init nuxt.js and create server listening on localhost:4000
-test.before('Init Nuxt.js', async t => {
-  const options = {
-    rootDir: resolve(__dirname, 'fixtures/ssr'),
-    dev: false,
-    render: {
-      resourceHints: false
-    },
-    build: {
-      extractCSS: true
-    }
-  }
-  nuxt = new Nuxt(options)
-  await new Builder(nuxt).build()
-  await nuxt.listen(port, 'localhost')
+test.serial('Init Nuxt.js', async t => {
+  const rootDir = resolve(__dirname, 'fixtures/ssr')
+  const config = require(resolve(rootDir, 'nuxt.config.js'))
+  config.rootDir = rootDir
+
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    await new Builder(nuxt).build()
+    await nuxt.listen(port, 'localhost')
+  })
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
 // == Uniq Test ==
@@ -121,6 +121,6 @@ test('stress test with asyncData', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', t => {
-  nuxt.close()
+test.after.always('Closing server and nuxt.js', async t => {
+  await nuxt.close()
 })
diff --git a/test/with-config.test.js b/test/with-config.test.js
index 5904719f94..d70faa13b1 100644
--- a/test/with-config.test.js
+++ b/test/with-config.test.js
@@ -16,19 +16,23 @@ test.before('Init Nuxt.js', async t => {
   let config = require(resolve(rootDir, 'nuxt.config.js'))
   config.rootDir = rootDir
   config.dev = false
-  nuxt = new Nuxt(config)
-  builder = new Builder(nuxt)
-  await interceptLog('building nuxt', async () => {
+
+  const logSpy = await interceptLog(async () => {
+    nuxt = new Nuxt(config)
+    builder = new Builder(nuxt)
     await builder.build()
+    await nuxt.listen(port, 'localhost')
   })
-  await nuxt.listen(port, 'localhost')
+
+  t.true(logSpy.calledWithMatch('DONE'))
+  t.true(logSpy.calledWithMatch('OPEN'))
 })
 
-test('/', async t => {
-  const logSpy = await interceptLog(async () => {
-    const { html } = await nuxt.renderRoute('/')
-    t.true(html.includes('<h1>I have custom configurations</h1>'))
-  })
+test.serial('/', async t => {
+  const logSpy = await interceptLog()
+  const { html } = await nuxt.renderRoute('/')
+  t.true(html.includes('<h1>I have custom configurations</h1>'))
+  release()
   t.true(logSpy.calledOnce)
   t.is(logSpy.args[0][0], 'Test plugin!')
 })
@@ -58,21 +62,20 @@ test('/ (custom postcss.config.js)', async t => {
   t.true(html.includes('::-webkit-input-placeholder'))
 })
 
-test('/test/ (router base)', async t => {
-  const logSpy = await interceptLog(async () => {
-    const window = await nuxt.renderAndGetWindow(url('/test/'))
-
-    const html = window.document.body.innerHTML
-    t.is(window.__NUXT__.layout, 'default')
-    t.true(html.includes('<h1>Default layout</h1>'))
-    t.true(html.includes('<h1>I have custom configurations</h1>'))
-  })
+test.serial('/test/ (router base)', async t => {
+  const logSpy = await interceptLog()
+  const window = await nuxt.renderAndGetWindow(url('/test/'))
 
+  const html = window.document.body.innerHTML
+  t.is(window.__NUXT__.layout, 'default')
+  t.true(html.includes('<h1>Default layout</h1>'))
+  t.true(html.includes('<h1>I have custom configurations</h1>'))
+  release()
   t.true(logSpy.calledOnce)
   t.is(logSpy.args[0][0], 'Test plugin!')
 })
 
-test('/test/about (custom layout)', async t => {
+test.serial('/test/about (custom layout)', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/about'))
   t.true(logSpy.calledOnce)
@@ -85,7 +88,7 @@ test('/test/about (custom layout)', async t => {
   t.true(html.includes('<h1>About page</h1>'))
 })
 
-test('/test/desktop (custom layout in desktop folder)', async t => {
+test.serial('/test/desktop (custom layout in desktop folder)', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/desktop'))
   t.true(logSpy.calledOnce)
@@ -98,7 +101,7 @@ test('/test/desktop (custom layout in desktop folder)', async t => {
   t.true(html.includes('<h1>Desktop page</h1>'))
 })
 
-test('/test/mobile (custom layout in mobile folder)', async t => {
+test.serial('/test/mobile (custom layout in mobile folder)', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/mobile'))
   t.true(logSpy.calledOnce)
@@ -111,7 +114,7 @@ test('/test/mobile (custom layout in mobile folder)', async t => {
   t.true(html.includes('<h1>Mobile page</h1>'))
 })
 
-test('/test/env', async t => {
+test.serial('/test/env', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/env'))
   t.true(logSpy.calledOnce)
@@ -129,7 +132,7 @@ test('/test/env', async t => {
   t.true(html.includes('"obj": {'))
 })
 
-test('/test/error', async t => {
+test.serial('/test/error', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/error'))
   t.true(logSpy.calledOnce)
@@ -140,7 +143,7 @@ test('/test/error', async t => {
   t.true(html.includes('Error page'))
 })
 
-test('/test/user-agent', async t => {
+test.serial('/test/user-agent', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/user-agent'))
   t.true(logSpy.calledOnce)
@@ -151,7 +154,7 @@ test('/test/user-agent', async t => {
   t.true(html.includes('<pre>Mozilla'))
 })
 
-test('/test/about-bis (added with extendRoutes)', async t => {
+test.serial('/test/about-bis (added with extendRoutes)', async t => {
   const logSpy = await interceptLog()
   const window = await nuxt.renderAndGetWindow(url('/test/about-bis'))
   t.true(logSpy.calledOnce)
@@ -190,6 +193,6 @@ test('Check build.styleResources for style-resources-loader', async t => {
 })
 
 // Close server and ask nuxt to stop listening to file changes
-test.after('Closing server and nuxt.js', async t => {
+test.after.always('Closing server and nuxt.js', async t => {
   await nuxt.close()
 })

From ada5ffb84eeefed0d3318948aef493e749da9d70 Mon Sep 17 00:00:00 2001
From: pimlie <pimlie@hotmail.com>
Date: Sun, 17 Dec 2017 22:14:05 +0100
Subject: [PATCH 2/2] Fix stdout/stderr interceptors

---
 test/basic.dev.test.js  | 2 +-
 test/helpers/console.js | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/basic.dev.test.js b/test/basic.dev.test.js
index efdf90e3f4..8bd9e552a5 100644
--- a/test/basic.dev.test.js
+++ b/test/basic.dev.test.js
@@ -38,7 +38,7 @@ test.serial('Init Nuxt.js', async t => {
 })
 
 test.serial('remove mixins in live reloading', async t => {
-  const spies = await intercept()
+  const spies = await intercept({ log: true, error: true, stderr: true })
   await nuxt.renderRoute(url('/'))
   t.true(spies.log.calledWith('I am mixin'))
 
diff --git a/test/helpers/console.js b/test/helpers/console.js
index 036883e8b1..6a89271b90 100644
--- a/test/helpers/console.js
+++ b/test/helpers/console.js
@@ -80,8 +80,8 @@ export async function intercept(levels, msg, cb) {
   }
 
   if (levels && levels.stderr) {
-    context.stdout = process.stderr.write
-    spies.stdout = process.stderr.write = sinon.spy()
+    context.stderr = process.stderr.write
+    spies.stderr = process.stderr.write = sinon.spy()
   }
 
   if (cb) {
@@ -126,8 +126,8 @@ export async function interceptError(msg, cb) {
 }
 
 export async function interceptStdout(msg, cb) {
-  const { stderr } = await intercept({ stdout: true }, msg, cb)
-  return stderr
+  const { stdout } = await intercept({ stdout: true }, msg, cb)
+  return stdout
 }
 
 export async function interceptStderr(msg, cb) {