expeditaea 1.0.0

package/packages/cli/test/unit/utils.test.js

@@ -0,0 +1,273 @@
+import { getDefaultNuxtConfig } from '@nuxt/config'
+import { TARGETS } from '@nuxt/utils'
+import { consola } from '../utils'
+import { loadNuxtConfig } from '../../src/utils/config'
+import * as utils from '../../src/utils'
+import { showBanner } from '../../src/utils/banner'
+import { showMemoryUsage } from '../../src/utils/memory'
+import * as fmt from '../../src/utils/formatting'
+
+jest.mock('std-env', () => ({
+  test: false,
+  minimalCLI: false
+}))
+jest.mock('boxen', () => text => `[boxen] ${text}`)
+
+describe('cli/utils', () => {
+  afterEach(() => jest.resetAllMocks())
+
+  test('loadNuxtConfig: defaults', async () => {
+    const argv = {
+      _: ['.'],
+      'config-file': 'nuxt.config.js',
+      universal: true
+    }
+
+    const options = await loadNuxtConfig(argv)
+    expect(options.rootDir).toBe(process.cwd())
+    expect(options.mode).toBeUndefined()
+    expect(options.ssr).toBe(true)
+    expect(options.server.host).toBe('localhost')
+    expect(options.server.port).toBe(3000)
+    expect(options.server.socket).not.toBeDefined()
+  })
+
+  test('loadNuxtConfig: config-file', async () => {
+    const argv = {
+      _: [__dirname],
+      'config-file': '../fixtures/nuxt.config.js',
+      spa: true
+    }
+
+    const options = await loadNuxtConfig(argv)
+    expect(options.testOption).toBe(true)
+    expect(options.rootDir).toBe('/some/path')
+    expect(options.mode).toBe('supercharged')
+    expect(options.ssr).toBe(false)
+    expect(options.server.host).toBe('nuxt-host')
+    expect(options.server.port).toBe(3001)
+    expect(options.server.socket).toBe('/var/run/nuxt.sock')
+  })
+
+  test('loadNuxtConfig: not-existing config-file', async () => {
+    const argv = {
+      _: [__dirname],
+      'config-file': '../fixtures/nuxt.doesnt-exist.js'
+    }
+
+    const options = await loadNuxtConfig(argv)
+    expect(options.testOption).not.toBeDefined()
+
+    expect(consola.fatal).toHaveBeenCalledTimes(1)
+    expect(consola.fatal).toHaveBeenCalledWith(expect.stringMatching(/Config file not found/))
+  })
+
+  test('loadNuxtConfig: async config-file', async () => {
+    const argv = {
+      _: [__dirname],
+      'config-file': '../fixtures/nuxt.async-config.js',
+      hostname: 'async-host',
+      port: 3002,
+      'unix-socket': '/var/run/async.sock'
+    }
+
+    const options = await loadNuxtConfig(argv)
+    expect(options.testOption).toBe(true)
+    expect(options.mode).toBe('supercharged')
+    expect(options.server.host).toBe('async-host')
+    expect(options.server.port).toBe(3002)
+    expect(options.server.socket).toBe('/var/run/async.sock')
+  })
+
+  test('loadNuxtConfig: passes context to config fn', async () => {
+    const argv = {
+      _: [__dirname],
+      'config-file': '../fixtures/nuxt.fn-config.js'
+    }
+
+    const context = { command: 'test', dev: true }
+    const options = await loadNuxtConfig(argv, context)
+    expect(options.context.command).toBe('test')
+    expect(options.context.dev).toBe(true)
+  })
+
+  test('loadNuxtConfig: async config-file with error', async () => {
+    const argv = {
+      _: [__dirname],
+      'config-file': '../fixtures/nuxt.async-error.js'
+    }
+
+    const options = await loadNuxtConfig(argv)
+    expect(options.testOption).not.toBeDefined()
+
+    expect(consola.error).toHaveBeenCalledTimes(1)
+    expect(consola.error).toHaveBeenCalledWith(new Error('Async Config Error'))
+    expect(consola.fatal).toHaveBeenCalledWith('Error while fetching async configuration')
+  })
+
+  test('normalizeArg: normalize string argument in command', () => {
+    expect(utils.normalizeArg('true')).toBe(true)
+    expect(utils.normalizeArg('false')).toBe(false)
+    expect(utils.normalizeArg(true)).toBe(true)
+    expect(utils.normalizeArg(false)).toBe(false)
+    expect(utils.normalizeArg('')).toBe(true)
+    expect(utils.normalizeArg(undefined, 'default')).toBe('default')
+    expect(utils.normalizeArg('text')).toBe('text')
+  })
+
+  test('nuxtServerConfig: server env', () => {
+    const options = getDefaultNuxtConfig({
+      env: {
+        ...process.env,
+        HOST: 'env-host',
+        PORT: 3003,
+        UNIX_SOCKET: '/var/run/env.sock'
+      }
+    })
+
+    expect(options.server.host).toBe('env-host')
+    expect(options.server.port).toBe(3003)
+    expect(options.server.socket).toBe('/var/run/env.sock')
+  })
+
+  test('indent', () => {
+    expect(fmt.indent(4)).toBe('    ')
+  })
+
+  test('indent custom char', () => {
+    expect(fmt.indent(4, '-')).toBe('----')
+  })
+
+  test('showBanner prints full-info box with memory usage', () => {
+    const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => {})
+    const successBox = jest.fn().mockImplementation((m, t) => t + m)
+    jest.spyOn(fmt, 'successBox').mockImplementation(successBox)
+
+    const badgeMessages = ['badgeMessage']
+    const bannerColor = 'green'
+    const listeners = [
+      { url: 'first' },
+      { url: 'second' }
+    ]
+
+    showBanner({
+      options: {
+        render: {
+          ssr: true
+        },
+        cli: {
+          badgeMessages,
+          bannerColor
+        }
+      },
+      server: {
+        listeners
+      }
+    })
+
+    expect(successBox).toHaveBeenCalledTimes(1)
+    expect(stdout).toHaveBeenCalledTimes(1)
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('Nuxt'))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching(`Listening: ${listeners[0].url}`))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching(`Listening: ${listeners[1].url}`))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('Memory usage'))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('badgeMessage'))
+    stdout.mockRestore()
+  })
+
+  test('showBanner doesnt print memory usage', () => {
+    const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => {})
+    const successBox = jest.fn().mockImplementation((m, t) => t + m)
+    jest.spyOn(fmt, 'successBox').mockImplementation(successBox)
+
+    showBanner({
+      options: {
+        cli: {
+          badgeMessages: [],
+          bannerColor: 'green'
+        },
+        render: {
+          ssr: false
+        }
+      },
+      server: {
+        listeners: []
+      }
+    }, false)
+
+    expect(successBox).toHaveBeenCalledTimes(1)
+    expect(stdout).toHaveBeenCalledTimes(1)
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('Nuxt'))
+    expect(stdout).not.toHaveBeenCalledWith(expect.stringMatching('Memory usage'))
+    stdout.mockRestore()
+  })
+
+  test('showBanner does print env, rendering mode and target', () => {
+    const stdout = jest.spyOn(process.stdout, 'write').mockImplementation(() => {})
+    const successBox = jest.fn().mockImplementation((m, t) => t + m)
+    jest.spyOn(fmt, 'successBox').mockImplementation(successBox)
+
+    showBanner({
+      options: {
+        dev: false,
+        target: TARGETS.static,
+        render: {
+          ssr: false
+        },
+        cli: {
+          bannerColor: 'green',
+          badgeMessages: []
+        }
+      },
+      server: {
+        listeners: []
+      }
+    }, false)
+
+    expect(successBox).toHaveBeenCalledTimes(1)
+    expect(stdout).toHaveBeenCalledTimes(1)
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('Nuxt'))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('▸ Environment:'))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('▸ Rendering:'))
+    expect(stdout).toHaveBeenCalledWith(expect.stringMatching('▸ Target:'))
+    stdout.mockRestore()
+  })
+
+  test('showMemoryUsage prints memory usage', () => {
+    showMemoryUsage()
+
+    expect(consola.info).toHaveBeenCalledTimes(1)
+    expect(consola.info).toHaveBeenCalledWith(expect.stringMatching('Memory usage'))
+  })
+
+  test('forceExit exits after timeout', () => {
+    jest.useFakeTimers()
+    const exit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+    const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(() => {})
+
+    utils.forceExit('test', 1)
+    expect(exit).not.toHaveBeenCalled()
+    jest.runAllTimers()
+
+    expect(stderr).toHaveBeenCalledWith(expect.stringMatching('Nuxt will now force exit'))
+    expect(exit).toHaveBeenCalledTimes(1)
+
+    stderr.mockRestore()
+    exit.mockRestore()
+    jest.useRealTimers()
+  })
+
+  test('forceExit exits immediately without timeout', () => {
+    jest.useFakeTimers()
+    const exit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+    const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(() => {})
+
+    utils.forceExit('test', false)
+    expect(stderr).not.toHaveBeenCalledWith()
+    expect(exit).toHaveBeenCalledTimes(1)
+
+    stderr.mockRestore()
+    exit.mockRestore()
+    jest.useRealTimers()
+  })
+})

package/packages/cli/test/unit/webpack.test.js

@@ -0,0 +1,50 @@
+import path from 'path'
+import util from 'util'
+import consola from 'consola'
+import prettyFormat from 'pretty-format'
+import { NuxtCommand, getWebpackConfig } from '../../src/index'
+import webpackCommand from '../../src/commands/webpack'
+
+const replaceAll = (str, a, b) => str.split(a).join(b)
+const nuxtDir = path.join(__dirname, '../../../..')
+const maskDir = str => replaceAll(str, nuxtDir, '<nuxtDir>')
+
+const tests = [
+  'devtool',
+  'resolve alias',
+  'module.rules',
+  'module.rules test=.jsx',
+  'module.rules loader=vue-',
+  'module.rules loader=.*-loader',
+  'nuxt webpack module rules test=.pug oneOf use.0=raw'
+]
+
+describe('webpack', () => {
+  beforeAll(() => {
+    process.stdout.isTTY = false
+    util.formatWithOptions = (opts, obj) => prettyFormat(obj)
+  })
+
+  afterEach(() => {
+    jest.resetAllMocks()
+  })
+
+  test.posix('getWebpackConfig()', async () => {
+    const webpackConfig = await getWebpackConfig('Client')
+    expect(maskDir(prettyFormat(webpackConfig.module.rules[0]))).toMatchSnapshot()
+  })
+
+  test.posix('nuxt webpack no match', async () => {
+    const cmd = NuxtCommand.from(webpackCommand, ['module.rules', 'loader=foobar'])
+    await cmd.run()
+    expect(maskDir(consola.warn.mock.calls[0][0])).toBe('No match in webpack config for `loader=foobar`')
+  })
+
+  for (const testCase of tests) {
+    test.posix('nuxt webpack ' + testCase, async () => {
+      const cmd = NuxtCommand.from(webpackCommand, testCase.split(' '))
+      await cmd.run()
+      expect(maskDir(consola.log.mock.calls[0][0])).toMatchSnapshot()
+    })
+  }
+})

package/packages/cli/test/utils/index.js

@@ -0,0 +1,14 @@
+import path from 'path'
+import consola from 'consola'
+
+export * from './mocking'
+export { NuxtCommand } from '../../src'
+
+consola.mockTypes(() => jest.fn())
+
+const localPath = modulePath => path.resolve(process.cwd(), 'node_modules', modulePath)
+
+export {
+  consola,
+  localPath
+}

package/packages/cli/test/utils/mocking.js

@@ -0,0 +1,121 @@
+import * as imports from '../../src/imports'
+import Command from '../../src/command'
+
+jest.mock('../../src/imports', () => {
+  return {
+    core: jest.fn().mockImplementation(() => ({
+      Nuxt () {}
+    })),
+    builder: jest.fn().mockImplementation(() => ({
+      Builder () {}
+    })),
+    generator: jest.fn().mockImplementation(() => ({
+      Generator () {}
+    })),
+    server: () => ({
+      Listener: class { listen () { } }
+    }),
+    webpack: jest.fn().mockImplementation(() => ({
+      BundleBuilder () {}
+    }))
+  }
+})
+
+export const mockGetNuxt = (options = {}, implementation = {}) => {
+  Command.prototype.getNuxt = jest.fn().mockImplementationOnce(() => {
+    return Object.assign({
+      hook: jest.fn(),
+      server: {
+        listen: jest.fn()
+      },
+      close: jest.fn(),
+      options
+    }, implementation)
+  })
+}
+
+export const mockGetBuilder = (ret) => {
+  const build = jest.fn().mockImplementationOnce(() => ret)
+
+  Command.prototype.getBuilder = jest.fn().mockImplementationOnce(() => ({ build }))
+
+  return build
+}
+
+export const mockGetGenerator = (ret) => {
+  const generate = jest.fn()
+  if (ret) {
+    generate.mockImplementationOnce(ret)
+  } else {
+    generate.mockImplementationOnce(() => ({ errors: [] }))
+  }
+
+  Command.prototype.getGenerator = jest.fn().mockImplementationOnce(() => ({ generate }))
+
+  return generate
+}
+
+export const mockGetNuxtStart = (ssr) => {
+  const listen = jest.fn().mockImplementationOnce(() => {
+    return Promise.resolve()
+  })
+
+  mockGetNuxt({
+    rootDir: '.',
+    render: {
+      ssr
+    }
+  }, {
+    server: {
+      listen,
+      listeners: []
+    }
+  })
+
+  return { listen }
+}
+
+export const mockGetNuxtConfig = (config = {}) => {
+  const spy = jest.fn()
+  spy.mockReturnValue(config)
+  Command.prototype.getNuxtConfig = spy
+  return spy
+}
+
+export const mockNuxt = (implementation) => {
+  const Nuxt = function () {}
+  Object.assign(Nuxt.prototype, {
+    hook (type, fn) {
+      if (type === 'watch:restart') {
+        Nuxt.fileRestartHook = fn
+      }
+    },
+    options: {},
+    callHook: jest.fn(),
+    clearHook: jest.fn(),
+    clearHooks: jest.fn(),
+    close: jest.fn(),
+    ready: jest.fn(),
+    server: {
+      listeners: [],
+      listen: jest.fn().mockImplementationOnce(() => Promise.resolve())
+    }
+  }, implementation || {})
+
+  imports.core.mockImplementation(() => ({ Nuxt }))
+
+  return Nuxt
+}
+
+export const mockBuilder = (implementation) => {
+  const Builder = function () {}
+  Object.assign(Builder.prototype, {
+    build: jest.fn().mockImplementationOnce(() => Promise.resolve()),
+    unwatch: jest.fn().mockImplementationOnce(() => Promise.resolve()),
+    watchRestart: jest.fn().mockImplementationOnce(() => Promise.resolve())
+  }, implementation || {})
+
+  imports.builder.mockImplementation(() => ({ Builder }))
+
+  return Builder
+}

package/packages/config/index.d.ts

@@ -0,0 +1,3 @@
+// Dummy type definition file to provide backward compatibility
+// around Nuxt modules extending `@nuxt/config` for Nuxt < 2.9
+declare module '@nuxt/config'

package/packages/config/package.js

@@ -0,0 +1,3 @@
+export default {
+  build: true
+}

package/packages/config/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@nuxt/config",
+  "version": "2.15.6",
+  "repository": "nuxt/nuxt.js",
+  "license": "MIT",
+  "main": "dist/config.js",
+  "typings": "index.d.ts",
+  "files": [
+    "dist",
+    "index.d.ts"
+  ],
+  "dependencies": {
+    "@nuxt/utils": "2.15.6",
+    "consola": "^2.15.3",
+    "defu": "^4.0.1",
+    "destr": "^1.1.0",
+    "dotenv": "^9.0.2",
+    "lodash": "^4.17.21",
+    "rc9": "^1.2.0",
+    "std-env": "^2.3.0",
+    "ufo": "^0.7.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/config/src/config/_app.js

@@ -0,0 +1,75 @@
+export default () => ({
+  vue: {
+    config: {
+      silent: undefined, // = !dev
+      performance: undefined // = dev
+    }
+  },
+
+  vueMeta: null,
+
+  head: {
+    meta: [],
+    link: [],
+    style: [],
+    script: []
+  },
+
+  fetch: {
+    server: true,
+    client: true
+  },
+
+  plugins: [],
+
+  extendPlugins: null,
+
+  css: [],
+
+  layouts: {},
+
+  ErrorPage: null,
+
+  loading: {
+    color: 'black',
+    failedColor: 'red',
+    height: '2px',
+    throttle: 200,
+    duration: 5000,
+    continuous: false,
+    rtl: false,
+    css: true
+  },
+
+  loadingIndicator: 'default',
+
+  pageTransition: {
+    name: 'page',
+    mode: 'out-in',
+    appear: false,
+    appearClass: 'appear',
+    appearActiveClass: 'appear-active',
+    appearToClass: 'appear-to'
+  },
+
+  layoutTransition: {
+    name: 'layout',
+    mode: 'out-in'
+  },
+
+  features: {
+    store: true,
+    layouts: true,
+    meta: true,
+    middleware: true,
+    transitions: true,
+    deprecations: true,
+    validate: true,
+    asyncData: true,
+    fetch: true,
+    clientOnline: true,
+    clientPrefetch: true,
+    componentAliases: true,
+    componentClientOnly: true
+  }
+})

package/packages/config/src/config/_common.js

@@ -0,0 +1,93 @@
+import { capitalize } from 'lodash'
+import env from 'std-env'
+import { TARGETS } from '@nuxt/utils'
+
+export default () => ({
+  // Env
+  dev: Boolean(env.dev),
+  test: Boolean(env.test),
+  debug: undefined, // = dev
+  env: {},
+
+  createRequire: undefined,
+
+  // Target
+  target: TARGETS.server,
+
+  // Rendering
+  ssr: true,
+
+  // Mode (deprecated)
+  mode: undefined,
+
+  // Modern
+  modern: undefined,
+
+  // Modules
+  modules: [],
+  buildModules: [],
+  _modules: [],
+
+  globalName: undefined,
+  globals: {
+    id: globalName => `__${globalName}`,
+    nuxt: globalName => `$${globalName}`,
+    context: globalName => `__${globalName.toUpperCase()}__`,
+    pluginPrefix: globalName => globalName,
+    readyCallback: globalName => `on${capitalize(globalName)}Ready`,
+    loadedCallback: globalName => `_on${capitalize(globalName)}Loaded`
+  },
+
+  // Server
+  serverMiddleware: [],
+
+  // Dirs and extensions
+  _nuxtConfigFile: undefined,
+  srcDir: undefined,
+  buildDir: '.nuxt',
+  modulesDir: [
+    'node_modules'
+  ],
+  dir: {
+    assets: 'assets',
+    app: 'app',
+    layouts: 'layouts',
+    middleware: 'middleware',
+    pages: 'pages',
+    static: 'static',
+    store: 'store'
+  },
+  extensions: [],
+  styleExtensions: ['css', 'pcss', 'postcss', 'styl', 'stylus', 'scss', 'sass', 'less'],
+  alias: {},
+
+  // Ignores
+  ignoreOptions: undefined,
+  ignorePrefix: '-',
+  ignore: [
+    '**/*.test.*',
+    '**/*.spec.*'
+  ],
+
+  // Watch
+  watch: [],
+  watchers: {
+    rewatchOnRawEvents: undefined,
+    webpack: {
+      aggregateTimeout: 1000
+    },
+    chokidar: {
+      ignoreInitial: true
+    }
+  },
+
+  // Editor
+  editor: undefined,
+
+  // Hooks
+  hooks: null,
+
+  // runtimeConfig
+  privateRuntimeConfig: {},
+  publicRuntimeConfig: {}
+})