expeditaea 1.0.0

package/packages/server/test/listener.test.js

@@ -0,0 +1,428 @@
+import http from 'http'
+import https from 'https'
+import enableDestroy from 'server-destroy'
+import ip from 'ip'
+import consola from 'consola'
+import pify from 'pify'
+
+import Listener from '../src/listener'
+
+jest.mock('http')
+jest.mock('https')
+jest.mock('server-destroy')
+jest.mock('ip')
+jest.mock('pify')
+
+describe('server: listener', () => {
+  const mockServer = () => {
+    const server = {
+      address: jest.fn(),
+      on: jest.fn(),
+      listen: jest.fn((listenArgs, callback) => {
+        Promise.resolve().then(callback)
+        return server
+      }),
+      destroy: jest.fn()
+    }
+    return server
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should construct listener', () => {
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      socket: jest.fn(),
+      https: { id: 'test-listener-https' },
+      app: jest.fn(),
+      dev: false
+    }
+    const listener = new Listener(options)
+
+    expect(listener.port).toEqual(options.port)
+    expect(listener.host).toEqual(options.host)
+    expect(listener.socket).toEqual(options.socket)
+    expect(listener.https).toEqual(options.https)
+    expect(listener.app).toEqual(options.app)
+    expect(listener.dev).toEqual(options.dev)
+    expect(listener.listening).toEqual(false)
+    expect(listener._server).toBe(null)
+    expect(listener.server).toBe(null)
+    expect(listener.address).toBe(null)
+    expect(listener.url).toBe(null)
+  })
+
+  test('should listen http host and port', async () => {
+    const server = mockServer()
+    http.createServer.mockReturnValueOnce(server)
+
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      https: false,
+      app: jest.fn(),
+      dev: false
+    }
+    const listener = new Listener(options)
+    listener.computeURL = jest.fn()
+
+    await listener.listen()
+
+    expect(http.createServer).toBeCalledTimes(1)
+    expect(http.createServer).toBeCalledWith(options.app)
+    expect(server.on).toBeCalledTimes(1)
+    expect(server.on).toBeCalledWith('error', expect.any(Function))
+    expect(server.listen).toBeCalledTimes(1)
+    expect(server.listen).toBeCalledWith(
+      {
+        host: options.host,
+        port: options.port,
+        exclusive: false
+      },
+      expect.any(Function)
+    )
+    expect(listener.server).toBe(server)
+    expect(enableDestroy).toBeCalledTimes(1)
+    expect(enableDestroy).toBeCalledWith(listener.server)
+    expect(pify).toBeCalledTimes(1)
+    expect(pify).toBeCalledWith(listener.server.destroy)
+    expect(listener.computeURL).toBeCalledTimes(1)
+    expect(listener.listening).toEqual(true)
+  })
+
+  test('should listen https host and port', async () => {
+    const server = mockServer()
+    https.createServer.mockReturnValueOnce(server)
+
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      https: { key: 'test-listener' },
+      app: jest.fn(),
+      dev: false
+    }
+    const listener = new Listener(options)
+    listener.computeURL = jest.fn()
+
+    await listener.listen()
+
+    expect(https.createServer).toBeCalledTimes(1)
+    expect(https.createServer).toBeCalledWith(options.https, options.app)
+    expect(server.on).toBeCalledTimes(1)
+    expect(server.on).toBeCalledWith('error', expect.any(Function))
+    expect(server.listen).toBeCalledTimes(1)
+    expect(server.listen).toBeCalledWith(
+      {
+        host: options.host,
+        port: options.port,
+        exclusive: false
+      },
+      expect.any(Function)
+    )
+    expect(listener.server).toBe(server)
+    expect(enableDestroy).toBeCalledTimes(1)
+    expect(enableDestroy).toBeCalledWith(listener.server)
+    expect(pify).toBeCalledTimes(1)
+    expect(pify).toBeCalledWith(listener.server.destroy)
+    expect(listener.computeURL).toBeCalledTimes(1)
+    expect(listener.listening).toEqual(true)
+  })
+
+  test('should listen unix socket host and port', async () => {
+    const server = mockServer()
+    http.createServer.mockReturnValueOnce(server)
+
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      https: false,
+      socket: '/var/nuxt/unix.socket',
+      app: jest.fn(),
+      dev: false
+    }
+    const listener = new Listener(options)
+    listener.computeURL = jest.fn()
+
+    await listener.listen()
+
+    expect(http.createServer).toBeCalledTimes(1)
+    expect(http.createServer).toBeCalledWith(options.app)
+    expect(server.on).toBeCalledTimes(1)
+    expect(server.on).toBeCalledWith('error', expect.any(Function))
+    expect(server.listen).toBeCalledTimes(1)
+    expect(server.listen).toBeCalledWith(
+      {
+        path: options.socket,
+        exclusive: false
+      },
+      expect.any(Function)
+    )
+    expect(listener.server).toBe(server)
+    expect(enableDestroy).toBeCalledTimes(1)
+    expect(enableDestroy).toBeCalledWith(listener.server)
+    expect(pify).toBeCalledTimes(1)
+    expect(pify).toBeCalledWith(listener.server.destroy)
+    expect(listener.computeURL).toBeCalledTimes(1)
+    expect(listener.listening).toEqual(true)
+  })
+
+  test('should prevent listening multiple times', async () => {
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      https: false,
+      app: jest.fn(),
+      dev: false
+    }
+    const listener = new Listener(options)
+    listener.computeURL = jest.fn()
+
+    listener.listening = true
+    await listener.listen()
+
+    expect(http.createServer).not.toBeCalled()
+  })
+
+  test('should throw error if error occurred or listen failed', async () => {
+    const server = mockServer()
+    http.createServer.mockReturnValueOnce(server)
+
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      https: false,
+      app: jest.fn(),
+      dev: false
+    }
+    const listener = new Listener(options)
+    listener.computeURL = jest.fn()
+    listener.serverErrorHandler = jest.fn()
+
+    const serverError = new Error('error occurred')
+    server.listen.mockImplementationOnce((listenArgs, callback) => {
+      Promise.resolve().then(callback)
+      const errorListener = server.on.mock.calls[0][1]
+      errorListener(serverError)
+      return server
+    })
+    await listener.listen()
+    expect(listener.serverErrorHandler).toBeCalledTimes(1)
+    expect(listener.serverErrorHandler).toBeCalledWith(serverError)
+
+    http.createServer.mockReturnValueOnce(server)
+    listener.serverErrorHandler.mockClear()
+
+    const listenError = new Error('listen failed')
+    server.listen.mockImplementationOnce((listenArgs, callback) => {
+      Promise.resolve().then(() => callback(listenError))
+      return server
+    })
+    await listener.listen()
+    expect(listener.serverErrorHandler).toBeCalledTimes(1)
+    expect(listener.serverErrorHandler).toBeCalledWith(listenError)
+  })
+
+  test('should compute http url', () => {
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      baseURL: '/'
+    }
+    const listener = new Listener(options)
+    listener.server = mockServer()
+
+    listener.server.address.mockReturnValueOnce({
+      address: 'localhost',
+      port: 3000
+    })
+    listener.computeURL()
+    expect(listener.host).toEqual('localhost')
+    expect(listener.port).toEqual(3000)
+    expect(listener.url).toEqual('http://localhost:3000/')
+
+    listener.server.address.mockReturnValueOnce({
+      address: '127.0.0.1',
+      port: 3001
+    })
+    listener.computeURL()
+    expect(listener.host).toEqual('localhost')
+    expect(listener.port).toEqual(3001)
+    expect(listener.url).toEqual('http://localhost:3001/')
+
+    ip.address.mockReturnValueOnce('192.168.0.1')
+    listener.server.address.mockReturnValueOnce({
+      address: '0.0.0.0',
+      port: 3002
+    })
+    listener.computeURL()
+    expect(listener.host).toEqual('192.168.0.1')
+    expect(listener.port).toEqual(3002)
+    expect(listener.url).toEqual('http://192.168.0.1:3002/')
+  })
+
+  test('should compute https url', () => {
+    const options = {
+      port: 3000,
+      host: 'localhost',
+      https: true,
+      baseURL: '/'
+    }
+    const listener = new Listener(options)
+    listener.server = mockServer()
+
+    listener.server.address.mockReturnValueOnce({
+      address: 'localhost',
+      port: 3000
+    })
+    listener.computeURL()
+    expect(listener.host).toEqual('localhost')
+    expect(listener.port).toEqual(3000)
+    expect(listener.url).toEqual('https://localhost:3000/')
+
+    listener.server.address.mockReturnValueOnce({
+      address: '127.0.0.1',
+      port: 3001
+    })
+    listener.computeURL()
+    expect(listener.host).toEqual('localhost')
+    expect(listener.port).toEqual(3001)
+    expect(listener.url).toEqual('https://localhost:3001/')
+
+    ip.address.mockReturnValueOnce('192.168.0.1')
+    listener.server.address.mockReturnValueOnce({
+      address: '0.0.0.0',
+      port: 3002
+    })
+    listener.computeURL()
+    expect(listener.host).toEqual('192.168.0.1')
+    expect(listener.port).toEqual(3002)
+    expect(listener.url).toEqual('https://192.168.0.1:3002/')
+  })
+
+  test('should compute unix socket url', () => {
+    const options = {
+      socket: true
+    }
+    const listener = new Listener(options)
+    listener.server = mockServer()
+
+    listener.server.address.mockReturnValueOnce('/var/nuxt/unix.socket')
+    listener.computeURL()
+
+    expect(listener.url).toEqual('unix+http:///var/nuxt/unix.socket')
+  })
+
+  test('should throw error in serverErrorHandler', () => {
+    const listener = new Listener({})
+
+    const error = new Error('server error')
+    expect(listener.serverErrorHandler(error)).rejects.toThrow(error)
+  })
+
+  test('should throw address in use error', () => {
+    const listener = new Listener({})
+    listener.host = 'localhost'
+    listener.port = 3000
+
+    const addressInUse = new Error('server error')
+    addressInUse.code = 'EADDRINUSE'
+    expect(listener.serverErrorHandler(addressInUse)).rejects.toThrow('Address `localhost:3000` is already in use.')
+  })
+
+  test('should throw address in use error for socket', () => {
+    const listener = new Listener({})
+    listener.socket = 'nuxt.socket'
+
+    const addressInUse = new Error('server error')
+    addressInUse.code = 'EADDRINUSE'
+    expect(listener.serverErrorHandler(addressInUse)).rejects.toThrow('Address `nuxt.socket` is already in use.')
+  })
+
+  test('should fallback to a random port in address in use error', async () => {
+    const listener = new Listener({ dev: true })
+    listener.host = 'localhost'
+    listener.port = 3000
+    listener.close = jest.fn(() => Promise.resolve())
+    listener.listen = jest.fn()
+
+    const addressInUse = new Error('server error')
+    addressInUse.code = 'EADDRINUSE'
+
+    await listener.serverErrorHandler(addressInUse)
+
+    expect(consola.warn).toBeCalledTimes(1)
+    expect(consola.warn).toBeCalledWith('Address `localhost:3000` is already in use.')
+    expect(consola.info).toBeCalledTimes(1)
+    expect(consola.info).toBeCalledWith('Trying a random port...')
+    expect(listener.port).toEqual('0')
+    expect(listener.close).toBeCalledTimes(1)
+    expect(listener.listen).toBeCalledTimes(1)
+  })
+
+  test('should reuse last random port', async () => {
+    const listener = new Listener({ dev: true, host: 'localhost', port: 3000 })
+    listener.host = 'localhost'
+    listener.close = jest.fn()
+    listener.listen = function () {
+      if (this.port === '0') {
+        this.port = Math.random()
+      }
+    }
+
+    const addressInUse = new Error('server error')
+    addressInUse.code = 'EADDRINUSE'
+
+    await listener.serverErrorHandler(addressInUse).catch(() => { })
+    const port1 = listener.port
+    await listener.serverErrorHandler(addressInUse).catch(() => { })
+    const port2 = listener.port
+
+    expect(port1).not.toBe(3000)
+    expect(port2).toBe(port1)
+  })
+
+  test('should close server', async () => {
+    const listener = new Listener({})
+    const server = mockServer()
+    listener.listening = true
+    listener._server = server
+    listener.server = server
+    listener.server.listening = true
+    listener.address = 'localhost'
+    listener.url = 'http://localhost:3000'
+
+    await listener.close()
+
+    expect(server.destroy).toBeCalledTimes(1)
+    expect(consola.debug).toBeCalledTimes(1)
+    expect(consola.debug).toBeCalledWith('server closed')
+    expect(listener.listening).toEqual(false)
+    expect(listener._server).toBe(null)
+    expect(listener.server).toBe(null)
+    expect(listener.address).toBe(null)
+    expect(listener.url).toBe(null)
+  })
+
+  test('should prevent destroying server if server is not listening', async () => {
+    const listener = new Listener({})
+    const server = mockServer()
+    listener.listening = true
+    listener._server = server
+    listener.server = server
+    listener.address = 'localhost'
+    listener.url = 'http://localhost:3000'
+
+    await listener.close()
+
+    expect(server.destroy).not.toBeCalled()
+    expect(consola.debug).not.toBeCalled()
+    expect(listener.listening).toEqual(false)
+    expect(listener._server).toBe(null)
+    expect(listener.server).toBe(null)
+    expect(listener.address).toBe(null)
+    expect(listener.url).toBe(null)
+  })
+})

package/packages/server/test/middleware/error.test.js

@@ -0,0 +1,221 @@
+import path from 'path'
+import fs from 'fs-extra'
+import consola from 'consola'
+
+import Youch from '@nuxtjs/youch'
+
+import createErrorMiddleware from '../../src/middleware/error'
+
+jest.mock('path')
+jest.mock('fs-extra')
+jest.mock('@nuxtjs/youch', () => jest.fn(() => ({
+  toHTML: jest.fn(() => 'youch html'),
+  toJSON: jest.fn(() => 'youch json')
+})))
+
+const createParams = () => ({
+  resources: { errorTemplate: jest.fn(() => 'error template') },
+  options: {
+    srcDir: '/var/nuxt/src',
+    rootDir: '/var/nuxt',
+    buildDir: '/var/nuxt/dist',
+    router: { base: '/' }
+  }
+})
+
+const createServerContext = () => ({
+  req: { headers: {} },
+  res: { setHeader: jest.fn(), end: jest.fn() },
+  next: jest.fn()
+})
+
+const errorFileName = 'test-error.js'
+const createError = () => {
+  const err = new Error('Error!')
+  err.stack = `Error!\n  at foo (webpack:///${errorFileName}?foo:1)`
+  return err
+}
+
+describe('server: errorMiddleware', () => {
+  beforeAll(() => {
+    path.join.mockImplementation((...args) => `join(${args.join(', ')})`)
+    path.resolve.mockImplementation((...args) => `resolve(${args.join(', ')})`)
+    fs.readFile.mockImplementation(() => Promise.resolve())
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should return error middleware', () => {
+    const errorMiddleware = createErrorMiddleware({})
+    expect(errorMiddleware).toBeInstanceOf(Function)
+  })
+
+  test('should send html error response', async () => {
+    const params = createParams()
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = {}
+    error.headers = { 'Custom-Header': 'test' }
+    const ctx = createServerContext()
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    expect(ctx.res.statusCode).toEqual(500)
+    expect(ctx.res.statusMessage).toEqual('RuntimeError')
+    expect(ctx.res.setHeader).toBeCalledTimes(4)
+    expect(ctx.res.setHeader).nthCalledWith(1, 'Content-Type', 'text/html; charset=utf-8')
+    expect(ctx.res.setHeader).nthCalledWith(2, 'Content-Length', Buffer.byteLength('error template'))
+    expect(ctx.res.setHeader).nthCalledWith(3, 'Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate')
+    expect(ctx.res.setHeader).nthCalledWith(4, 'Custom-Header', 'test')
+    expect(params.resources.errorTemplate).toBeCalledTimes(1)
+    expect(params.resources.errorTemplate).toBeCalledWith({ message: '', status: 500 })
+    expect(ctx.res.end).toBeCalledTimes(1)
+    expect(ctx.res.end).toBeCalledWith('error template', 'utf-8')
+  })
+
+  test('should send json error response', async () => {
+    const params = createParams()
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = {
+      statusCode: 404,
+      message: 'test error'
+    }
+    const ctx = createServerContext()
+    ctx.req.headers.accept = 'application/json'
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    const errJson = JSON.stringify({
+      status: error.statusCode,
+      message: error.message,
+      name: error.name
+    }, undefined, 2)
+    expect(consola.error).not.toBeCalled()
+    expect(ctx.res.statusCode).toEqual(404)
+    expect(ctx.res.setHeader).toBeCalledTimes(3)
+    expect(ctx.res.setHeader).nthCalledWith(1, 'Content-Type', 'text/json; charset=utf-8')
+    expect(ctx.res.setHeader).nthCalledWith(2, 'Content-Length', Buffer.byteLength(errJson))
+    expect(ctx.res.setHeader).nthCalledWith(3, 'Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate')
+    expect(params.resources.errorTemplate).not.toBeCalled()
+    expect(ctx.res.end).toBeCalledTimes(1)
+    expect(ctx.res.end).toBeCalledWith(errJson, 'utf-8')
+  })
+
+  test('should send html error response by youch in debug mode', async () => {
+    const params = createParams()
+    params.options.debug = true
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = new Error('test error')
+    error.statusCode = 503
+    const ctx = createServerContext()
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    const errHtml = 'youch html'
+
+    expect(ctx.res.statusCode).toEqual(503)
+    expect(ctx.res.setHeader).toBeCalledTimes(3)
+    expect(ctx.res.setHeader).nthCalledWith(1, 'Content-Type', 'text/html; charset=utf-8')
+    expect(ctx.res.setHeader).nthCalledWith(2, 'Content-Length', Buffer.byteLength(errHtml))
+    expect(ctx.res.setHeader).nthCalledWith(3, 'Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate')
+    expect(params.resources.errorTemplate).not.toBeCalled()
+    expect(ctx.res.end).toBeCalledTimes(1)
+    expect(ctx.res.end).toBeCalledWith(errHtml, 'utf-8')
+  })
+
+  test('should send json error response by youch in debug mode', async () => {
+    const params = createParams()
+    params.options.debug = true
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = {
+      statusCode: 404,
+      message: 'test error'
+    }
+    const ctx = createServerContext()
+    ctx.req.headers.accept = 'application/json'
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    const errJson = JSON.stringify('youch json', undefined, 2)
+
+    expect(ctx.res.statusCode).toEqual(404)
+    expect(ctx.res.setHeader).toBeCalledTimes(3)
+    expect(ctx.res.setHeader).nthCalledWith(1, 'Content-Type', 'text/json; charset=utf-8')
+    expect(ctx.res.setHeader).nthCalledWith(2, 'Content-Length', Buffer.byteLength(errJson))
+    expect(ctx.res.setHeader).nthCalledWith(3, 'Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate')
+    expect(params.resources.errorTemplate).not.toBeCalled()
+    expect(ctx.res.end).toBeCalledTimes(1)
+    expect(ctx.res.end).toBeCalledWith(errJson, 'utf-8')
+  })
+
+  test('should search all possible paths when read source', async () => {
+    const params = createParams()
+    params.options.debug = true
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = createError()
+    const ctx = createServerContext()
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    expect(fs.existsSync).nthCalledWith(1, `resolve(${params.options.srcDir}, ${errorFileName})`)
+    expect(fs.existsSync).nthCalledWith(2, `resolve(${params.options.rootDir}, ${errorFileName})`)
+    expect(fs.existsSync).nthCalledWith(3, `resolve(join(${params.options.buildDir}, dist, server), ${errorFileName})`)
+    expect(fs.existsSync).nthCalledWith(4, `resolve(${params.options.buildDir}, ${errorFileName})`)
+    expect(fs.existsSync).nthCalledWith(5, `resolve(${process.cwd()}, ${errorFileName})`)
+  })
+
+  test('should return source content after read source', async () => {
+    const params = createParams()
+    params.options.debug = true
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = {}
+    const ctx = createServerContext()
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    const frame = { fileName: errorFileName }
+    const readSource = Youch.mock.calls[0][2]
+    fs.existsSync.mockImplementationOnce(() => true)
+    fs.readFile.mockImplementationOnce(() => Promise.resolve('source content'))
+    await readSource(frame)
+
+    expect(frame).toEqual({
+      fileName: errorFileName,
+      contents: 'source content',
+      fullPath: errorFileName
+    })
+  })
+
+  test('should ignore if source file not exists', async () => {
+    const params = createParams()
+    params.options.debug = true
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = {}
+    const ctx = createServerContext()
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    const frame = { fileName: errorFileName }
+    const readSource = Youch.mock.calls[0][2]
+    fs.exists.mockReturnValueOnce(false)
+    await readSource(frame)
+    expect(frame).toEqual({ fileName: errorFileName })
+  })
+
+  test('should return if fileName is unknown when read source', async () => {
+    const params = createParams()
+    params.options.debug = true
+    const errorMiddleware = createErrorMiddleware(params)
+    const error = {}
+    const ctx = createServerContext()
+
+    await errorMiddleware(error, ctx.req, ctx.res, ctx.next)
+
+    const frame = {}
+    const readSource = Youch.mock.calls[0][2]
+    await readSource(frame)
+
+    expect(frame.fileName).toBeUndefined()
+  })
+})