Revert "test: bring cli test back"

lib/common/utils.js

@@ -13,29 +13,6 @@ export const waitFor = function waitFor(ms) {
   return new Promise(resolve => setTimeout(resolve, ms || 0))
 }
 
-/**
- * Prepare an object to pass to the createSportsSelectionView function
- * @param {Function} condition return true to stop the waiting
- * @param {Number} duration seconds totally wait
- * @param {Number} interval milliseconds interval to check the condition
- *
- * @returns {Boolean} true: timeout, false: condition becomes true within total time
- */
-export const waitUntil = async function waitUntil(condition, duration = 20, interval = 250) {
-  let iterator = 0
-  const steps = Math.floor(duration * 1000 / interval)
-
-  while (!condition() && iterator < steps) {
-    await waitFor(interval)
-    iterator++
-  }
-
-  if (iterator === steps) {
-    return true
-  }
-  return false
-}
-
 async function promiseFinally(fn, finalFn) {
   let result
   try {

test/fixtures/cli/cli.test.js

@@ -1,27 +0,0 @@
-import { exec } from 'child_process'
-import { resolve } from 'path'
-import { promisify } from 'util'
-
-const execify = promisify(exec)
-const rootDir = __dirname
-const nuxtBin = resolve(__dirname, '..', '..', '..', 'bin', 'nuxt')
-
-describe('cli', () => {
-  test('nuxt build', async () => {
-    const { stdout } = await execify(`node ${nuxtBin} build ${rootDir}`)
-
-    expect(stdout.includes('Compiled successfully')).toBe(true)
-  })
-
-  test('nuxt build -> error config', async () => {
-    await expect(execify(`node ${nuxtBin} build ${rootDir} -c config.js`)).rejects.toMatchObject({
-      stdout: expect.stringContaining('Could not load config file: config.js')
-    })
-  })
-
-  test('nuxt generate', async () => {
-    const { stdout } = await execify(`node ${nuxtBin} generate ${rootDir}`)
-
-    expect(stdout.includes('Generated successfully')).toBe(true)
-  })
-})

test/fixtures/cli/nuxt.config.js

@@ -1,22 +0,0 @@
-import consola from 'consola'
-
-export default {
-  hooks(hook) {
-    hook('build:done', builder => {
-      consola.success('Compiled successfully')
-    })
-    hook('generate:done', (generator, errors) => {
-      if (!errors || errors.length === 0) {
-        consola.success('Generated successfully')
-      } else {
-        consola.error('Generated failed')
-      }
-    })
-    hook('listen', (server, { port, host }) => {
-      consola.success(`Listening on http://${host}:${port}`)
-    })
-  },
-  generate: {
-    dir: '.nuxt-generate'
-  }
-}

test/fixtures/cli/pages/index.vue

@@ -1,3 +0,0 @@
-<template>
-  <div>CLI Test</div>
-</template>

test/unit/cli.test.js

@@ -1,29 +1,48 @@
-import { spawn } from 'child_process'
+import { exec, spawn } from 'child_process'
 import { resolve } from 'path'
-import { getPort, Utils, rp } from '../utils'
+import { promisify } from 'util'
+import { Utils, rp } from '../utils'
+
+const execify = promisify(exec)
+const rootDir = resolve(__dirname, '..', 'fixtures/basic')
 
 let port
-const rootDir = resolve(__dirname, '..', 'fixtures/cli')
-
 const url = route => 'http://localhost:' + port + route
 
 const nuxtBin = resolve(__dirname, '..', '..', 'bin', 'nuxt')
 
-describe('cli', () => {
+describe.skip('cli', () => {
+  test('nuxt build', async () => {
+    const { stdout } = await execify(`node ${nuxtBin} build ${rootDir}`)
+
+    expect(stdout.includes('Compiled successfully')).toBe(true)
+  })
+
+  test('nuxt build -> error config', async () => {
+    await expect(execify(`node ${nuxtBin} build ${rootDir} -c config.js`)).rejects.toMatchObject({
+      stderr: expect.stringContaining('Could not load config file')
+    })
+  })
+
   test('nuxt start', async () => {
     let stdout = ''
+    // let stderr = ''
     let error
     let exitCode
 
     const env = process.env
-    env.PORT = port = await getPort()
+    env.PORT = port
 
-    const nuxtStart = spawn('node', [nuxtBin, 'start', rootDir], { env })
+    const nuxtStart = spawn('node', [nuxtBin, 'start', rootDir], { env: env })
 
     nuxtStart.stdout.on('data', data => {
       stdout += data
     })
 
+    nuxtStart.stderr.on('data', data => {
+      // stderr += data
+    })
+
     nuxtStart.on('error', err => {
       error = err
     })
@@ -32,27 +51,37 @@ describe('cli', () => {
       exitCode = code
     })
 
-    // Wait max 20s for the starting
+    // Give the process max 20s to start
-    let timeout = await Utils.waitUntil(() => stdout.includes('Listening on'))
+    let iterator = 0
+    while (!stdout.includes('OPEN') && iterator < 80) {
+      await Utils.waitFor(250)
+      iterator++
+    }
 
-    if (timeout === true) {
+    if (iterator === 80) {
-      error = 'server failed to start successfully in 20 seconds'
+      test.log('WARN: server failed to start successfully in 20 seconds')
     }
 
     expect(error).toBe(undefined)
-    expect(stdout.includes('Listening on')).toBe(true)
+    expect(stdout.includes('OPEN')).toBe(true)
 
-    const html = await rp(url('/'))
+    const html = await rp(url('/users/1'))
-    expect(html).toMatch(('<div>CLI Test</div>'))
+    expect(html.includes('<h1>User: 1</h1>')).toBe(true)
 
     nuxtStart.kill()
 
     // Wait max 10s for the process to be killed
-    timeout = await Utils.waitUntil(() => exitCode !== undefined, 10)
+    iterator = 0
+    // eslint-disable-next-line  no-unmodified-loop-condition
+    while (exitCode === undefined && iterator < 40) {
+      await Utils.waitFor(250)
+      iterator++
+    }
 
-    if (timeout === true) {
+    if (iterator >= 40) {
-      console.warn( // eslint-disable-line no-console
+      // eslint-disable-line no-console
-        `we were unable to automatically kill the child process with pid: ${
+      test.log(
+        `WARN: we were unable to automatically kill the child process with pid: ${
           nuxtStart.pid
         }`
       )
@@ -60,4 +89,10 @@ describe('cli', () => {
 
     expect(exitCode).toBe(null)
   })
+
+  test('nuxt generate', async () => {
+    const { stdout } = await execify(`node ${nuxtBin} generate ${rootDir}`)
+
+    expect(stdout.includes('vue-ssr-client-manifest.json')).toBe(true)
+  })
 })

test/unit/utils.test.js

@@ -23,11 +23,6 @@ describe('utils', () => {
     await Utils.waitFor()
   })
 
-  test('waitUntil', async () => {
-    expect(await Utils.waitUntil(() => true, 0.1, 100)).toBe(false)
-    expect(await Utils.waitUntil(() => false, 0.1, 100)).toBe(true)
-  })
-
   test('timeout (promise)', async () => {
     const result = await Utils.timeout(Promise.resolve('time not run out'), 100)
     expect(result).toBe('time not run out')