Nuxt/packages/server/test/server.test.js

import path from 'path'
import connect from 'connect'
import consola from 'consola'
import serveStatic from 'serve-static'
import servePlaceholder from 'serve-placeholder'
import launchMiddleware from 'launch-editor-middleware'
import { determineGlobals, isUrl } from '@nuxt/utils'
import { VueRenderer } from '@nuxt/vue-renderer'

import Server from '../src/server'
import Listener from '../src/listener'
import ServerContext from '../src/context'
import renderAndGetWindow from '../src/jsdom'
import nuxtMiddleware from '../src/middleware/nuxt'
import errorMiddleware from '../src/middleware/error'
import createTimingMiddleware from '../src/middleware/timing'

jest.mock('connect')
jest.mock('serve-static')
jest.mock('serve-placeholder')
jest.mock('launch-editor-middleware')
jest.mock('@nuxt/utils')
jest.mock('@nuxt/vue-renderer')
jest.mock('../src/listener')
jest.mock('../src/context')
jest.mock('../src/jsdom')
jest.mock('../src/middleware/nuxt')
jest.mock('../src/middleware/error')
jest.mock('../src/middleware/timing')

describe('server: server', () => {
  const createNuxt = () => ({
    options: {
      dir: {
        static: 'var/nuxt/static'
      },
      srcDir: '/var/nuxt/src',
      buildDir: '/var/nuxt/build',
      globalName: 'test-global-name',
      globals: { id: 'test-globals' },
      build: {
        publicPath: '__nuxt_test'
      },
      router: {
        base: '/foo/'
      },
      render: {
        id: 'test-render',
        dist: {
          id: 'test-render-dist'
        },
        static: {
          id: 'test-render-static',
          prefix: 'test-render-static-prefix'
        }
      },
      server: {},
      serverMiddleware: []
    },
    hook: jest.fn(),
    ready: jest.fn(),
    callHook: jest.fn(),
    resolver: {
      requireModule: jest.fn()
    }
  })

  beforeAll(() => {
    jest.spyOn(path, 'join').mockImplementation((...args) => `join(${args.join(', ')})`)
    jest.spyOn(path, 'resolve').mockImplementation((...args) => `resolve(${args.join(', ')})`)
    connect.mockReturnValue({ use: jest.fn() })
    serveStatic.mockImplementation(dir => ({ id: 'test-serve-static', dir }))
    nuxtMiddleware.mockImplementation(options => ({
      id: 'test-nuxt-middleware',
      ...options
    }))
    errorMiddleware.mockImplementation(options => ({
      id: 'test-error-middleware',
      ...options
    }))
    createTimingMiddleware.mockImplementation(options => ({
      id: 'test-timing-middleware',
      ...options
    }))
    launchMiddleware.mockImplementation(options => ({
      id: 'test-open-in-editor-middleware',
      ...options
    }))
    servePlaceholder.mockImplementation(options => ({
      key: 'test-serve-placeholder',
      ...options
    }))
  })

  afterAll(() => {
    path.join.mockRestore()
    path.resolve.mockRestore()
  })

  beforeEach(() => {
    jest.clearAllMocks()
  })

  test('should construct server', () => {
    const nuxt = createNuxt()
    determineGlobals.mockReturnValueOnce({
      ...nuxt.options.globals,
      name: nuxt.options.globalName
    })
    let server = new Server(nuxt)

    expect(server.nuxt).toBe(nuxt)
    expect(server.options).toBe(nuxt.options)
    expect(server.publicPath).toBe('__nuxt_test')
    expect(server.resources).toEqual({})
    expect(server.listeners).toEqual([])
    expect(connect).toBeCalledTimes(1)
    expect(server.nuxt.hook).toBeCalledTimes(1)
    expect(server.nuxt.hook).toBeCalledWith('close', expect.any(Function))

    const closeHook = server.nuxt.hook.mock.calls[0][1]
    server.close = jest.fn()
    expect(server.close).not.toBeCalled()
    closeHook()
    expect(server.close).toBeCalledTimes(1)

    nuxt.options.build._publicPath = 'http://localhost:3000/test'
    isUrl.mockReturnValueOnce(true)
    server = new Server(nuxt)
    expect(server.publicPath).toBe(nuxt.options.build._publicPath)
  })

  test('should be ready for listening', async () => {
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    const renderer = {
      ready: jest.fn()
    }
    const context = jest.fn()
    VueRenderer.mockImplementationOnce(() => renderer)
    ServerContext.mockImplementationOnce(() => context)
    server.setupMiddleware = jest.fn()
    path.join.mockRestore()
    path.resolve.mockRestore()

    await server.ready()

    expect(server.nuxt.callHook).toBeCalledTimes(2)
    expect(server.nuxt.callHook).nthCalledWith(1, 'render:before', server, server.options.render)
    expect(server.nuxt.callHook).nthCalledWith(2, 'render:done', server)
    expect(ServerContext).toBeCalledTimes(1)
    expect(ServerContext).toBeCalledWith(server)
    expect(VueRenderer).toBeCalledTimes(1)
    expect(VueRenderer).toBeCalledWith(context)
    expect(server.renderer).toBe(renderer)
    expect(renderer.ready).toBeCalledTimes(1)
    expect(server.setupMiddleware).toBeCalledTimes(1)

    jest.spyOn(path, 'join').mockImplementation((...args) => `join(${args.join(', ')})`)
    jest.spyOn(path, 'resolve').mockImplementation((...args) => `resolve(${args.join(', ')})`)
  })

  test('should setup middleware', async () => {
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    server.useMiddleware = jest.fn()
    server.serverContext = { id: 'test-server-context' }

    await server.setupMiddleware()

    expect(server.nuxt.callHook).toBeCalledTimes(2)
    expect(server.nuxt.callHook).nthCalledWith(1, 'render:setupMiddleware', server.app)
    expect(server.nuxt.callHook).nthCalledWith(2, 'render:errorMiddleware', server.app)

    expect(server.useMiddleware).toBeCalledTimes(4)
    expect(serveStatic).toBeCalledTimes(2)
    expect(serveStatic).nthCalledWith(1, 'resolve(/var/nuxt/src, var/nuxt/static)', server.options.render.static)
    expect(server.useMiddleware).nthCalledWith(1, {
      dir: 'resolve(/var/nuxt/src, var/nuxt/static)',
      id: 'test-serve-static',
      prefix: 'test-render-static-prefix'
    })
    expect(serveStatic).nthCalledWith(2, 'resolve(/var/nuxt/build, dist, client)', server.options.render.dist)
    expect(server.useMiddleware).nthCalledWith(2, {
      handler: {
        dir: 'resolve(/var/nuxt/build, dist, client)',
        id: 'test-serve-static'
      },
      path: '__nuxt_test'
    })

    const nuxtMiddlewareOpts = {
      options: server.options,
      nuxt: server.nuxt,
      renderRoute: expect.any(Function),
      resources: server.resources
    }
    expect(nuxtMiddleware).toBeCalledTimes(1)
    expect(nuxtMiddleware).toBeCalledWith(nuxtMiddlewareOpts)
    expect(server.useMiddleware).nthCalledWith(3, {
      id: 'test-nuxt-middleware',
      ...nuxtMiddlewareOpts
    })

    const errorMiddlewareOpts = {
      resources: server.resources,
      options: server.options
    }
    expect(errorMiddleware).toBeCalledTimes(1)
    expect(errorMiddleware).toBeCalledWith(errorMiddlewareOpts)
    expect(server.useMiddleware).nthCalledWith(4, {
      id: 'test-error-middleware',
      ...errorMiddlewareOpts
    })
  })

  test('should setup compressor middleware', async () => {
    const nuxt = createNuxt()
    nuxt.options.render.compressor = jest.fn()
    const server = new Server(nuxt)
    server.useMiddleware = jest.fn()
    server.renderer = {
      context: { id: 'test-server-context' }
    }

    await server.setupMiddleware()
    expect(server.useMiddleware).nthCalledWith(1, nuxt.options.render.compressor)

    server.useMiddleware.mockClear()
    nuxt.options.render.compressor = { id: 'test-render-compressor' }
    nuxt.resolver.requireModule.mockImplementationOnce(name => jest.fn(options => ({
      name,
      ...options
    })))
    await server.setupMiddleware()
    expect(nuxt.resolver.requireModule).nthCalledWith(1, 'compression')
    expect(server.useMiddleware).nthCalledWith(1, {
      id: 'test-render-compressor',
      name: 'compression'
    })
  })

  test('should setup timing middleware', async () => {
    const nuxt = createNuxt()
    nuxt.options.server.timing = { id: 'test-server-timing' }
    const server = new Server(nuxt)
    server.useMiddleware = jest.fn()
    server.renderer = {
      context: { id: 'test-server-context' }
    }

    await server.setupMiddleware()

    expect(createTimingMiddleware).nthCalledWith(1, { id: 'test-server-timing' })
    expect(server.useMiddleware).nthCalledWith(1, { id: 'test-server-timing' })
  })

  test('should setup open-in-editor middleware', async () => {
    const nuxt = createNuxt()
    nuxt.options.dev = true
    nuxt.options.debug = true
    nuxt.options.editor = { id: 'test-editor' }
    const server = new Server(nuxt)
    server.useMiddleware = jest.fn()
    server.renderer = {
      context: { id: 'test-server-context' }
    }

    await server.setupMiddleware()

    expect(launchMiddleware).toBeCalledTimes(1)
    expect(launchMiddleware).toBeCalledWith({ id: 'test-editor' })

    expect(server.useMiddleware).nthCalledWith(3, {
      handler: { id: 'test-editor' },
      path: '__open-in-editor'
    })
  })

  test('should setup server middleware', async () => {
    const nuxt = createNuxt()
    nuxt.options.serverMiddleware = [
      { id: 'test-server-middleware-1' },
      { id: 'test-server-middleware-2' }
    ]
    const server = new Server(nuxt)
    server.useMiddleware = jest.fn()
    server.renderer = {
      context: { id: 'test-server-context' }
    }

    await server.setupMiddleware()

    expect(server.useMiddleware).nthCalledWith(3, { id: 'test-server-middleware-1' })
    expect(server.useMiddleware).nthCalledWith(4, { id: 'test-server-middleware-2' })
  })

  test('should setup fallback middleware', async () => {
    const nuxt = createNuxt()
    nuxt.options.render.fallback = {
      dist: { id: 'test-render-fallback-dist' },
      static: { id: 'test-render-fallback-static' }
    }
    const server = new Server(nuxt)
    server.useMiddleware = jest.fn()
    server.renderer = {
      context: { id: 'test-server-context' }
    }

    await server.setupMiddleware()
    expect(servePlaceholder).toBeCalledTimes(2)
    expect(server.useMiddleware).nthCalledWith(3, {
      handler: {
        id: 'test-render-fallback-dist',
        key: 'test-serve-placeholder'
      },
      path: '__nuxt_test'
    })
    expect(server.useMiddleware).nthCalledWith(4, {
      handler: {
        id: 'test-render-fallback-static',
        key: 'test-serve-placeholder'
      },
      path: '/'
    })

    servePlaceholder.mockClear()
    nuxt.options.render.fallback = {}
    await server.setupMiddleware()
    expect(servePlaceholder).not.toBeCalled()
  })

  test('should use object middleware', () => {
    const nuxt = createNuxt()
    nuxt.options.router = { base: '/' }
    const server = new Server(nuxt)
    const handler = jest.fn()

    server.useMiddleware({
      handler
    })

    expect(nuxt.resolver.requireModule).not.toBeCalled()
    expect(server.app.use).toBeCalledTimes(1)
    expect(server.app.use).toBeCalledWith(nuxt.options.router.base, handler)
  })

  test('should use function module middleware', () => {
    const nuxt = createNuxt()
    nuxt.options.router = { base: '/' }
    const server = new Server(nuxt)
    const handler = jest.fn()
    nuxt.resolver.requireModule.mockReturnValueOnce(handler)

    server.useMiddleware('test-middleware')

    expect(nuxt.resolver.requireModule).toBeCalledTimes(1)
    expect(nuxt.resolver.requireModule).toBeCalledWith('test-middleware')
    expect(server.app.use).toBeCalledTimes(1)
    expect(server.app.use).toBeCalledWith(nuxt.options.router.base, handler)
  })

  test('should use object module middleware', () => {
    const nuxt = createNuxt()
    nuxt.options.router = { base: '/' }
    const server = new Server(nuxt)
    const handler = jest.fn()
    nuxt.resolver.requireModule.mockReturnValueOnce({
      handler,
      prefix: false,
      path: '//middleware'
    })

    server.useMiddleware('test-middleware')

    expect(nuxt.resolver.requireModule).toBeCalledTimes(1)
    expect(nuxt.resolver.requireModule).toBeCalledWith('test-middleware')
    expect(server.app.use).toBeCalledTimes(1)
    expect(server.app.use).toBeCalledWith('/middleware', handler)
  })

  test('should throw error when module resolves failed', () => {
    const nuxt = createNuxt()
    nuxt.options.router = { base: '/' }
    const server = new Server(nuxt)
    const error = Error('middleware resolves failed')
    nuxt.resolver.requireModule.mockImplementationOnce(() => {
      throw error
    })

    expect(() => server.useMiddleware('test-middleware')).toThrow(error)
    expect(consola.error).toBeCalledTimes(1)
    expect(consola.error).toBeCalledWith(error)
  })

  test('should only log error when module resolves failed in dev mode', () => {
    const nuxt = createNuxt()
    nuxt.options.dev = true
    nuxt.options.router = { base: '/' }
    const server = new Server(nuxt)
    const error = Error('middleware resolves failed')
    nuxt.resolver.requireModule.mockImplementationOnce(() => {
      throw error
    })

    server.useMiddleware('test-middleware')

    expect(consola.error).toBeCalledTimes(1)
    expect(consola.error).toBeCalledWith(error)
  })

  test('should render route via renderer', () => {
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    server.renderer = { renderRoute: jest.fn() }

    server.renderRoute('test-render-route')

    expect(server.renderer.renderRoute).toBeCalledTimes(1)
    expect(server.renderer.renderRoute).toBeCalledWith('test-render-route')
  })

  test('should load resources via renderer', () => {
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    server.renderer = { loadResources: jest.fn() }

    server.loadResources('test-load-resources')

    expect(server.renderer.loadResources).toBeCalledTimes(1)
    expect(server.renderer.loadResources).toBeCalledWith('test-load-resources')
  })

  test('should render and get window', () => {
    const nuxt = createNuxt()
    const globals = {
      ...nuxt.options.globals,
      name: nuxt.options.globalName,
      loadedCallback: jest.fn()
    }
    determineGlobals.mockReturnValueOnce(globals)
    const server = new Server(nuxt)

    server.renderAndGetWindow('/render/window')

    expect(renderAndGetWindow).toBeCalledTimes(1)
    expect(renderAndGetWindow).toBeCalledWith('/render/window', {}, {
      loadedCallback: globals.loadedCallback,
      ssr: nuxt.options.render.ssr,
      globals
    })
  })

  test('should listen server', async () => {
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    const listener = {
      listen: jest.fn(),
      server: jest.fn()
    }
    Listener.mockImplementationOnce(() => {
      return listener
    })

    await server.listen(3000, 'localhost', '/var/nuxt/unix.socket')

    expect(Listener).toBeCalledWith({
      port: 3000,
      host: 'localhost',
      socket: '/var/nuxt/unix.socket',
      https: undefined,
      app: server.app,
      dev: server.options.dev,
      baseURL: '/foo/'
    })
    expect(listener.listen).toBeCalledTimes(1)
    expect(server.listeners).toEqual([ listener ])
    expect(server.nuxt.callHook).toBeCalledTimes(1)
    expect(server.nuxt.callHook).toBeCalledWith('listen', listener.server, listener)
  })

  test('should listen server via options.server', async () => {
    const nuxt = createNuxt()
    nuxt.options.server = {
      host: 'localhost',
      port: '3000',
      socket: '/var/nuxt/unix.socket',
      https: true
    }
    const server = new Server(nuxt)

    await server.listen()

    expect(Listener).toBeCalledWith({
      ...nuxt.options.server,
      app: server.app,
      dev: server.options.dev,
      baseURL: '/foo/'
    })
  })

  test('should close server', async () => {
    const removeAllListeners = jest.fn()
    connect.mockReturnValueOnce({ use: jest.fn(), removeAllListeners })
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    const listener = { close: jest.fn() }
    server.listeners = [ listener ]
    server.renderer = { close: jest.fn() }
    server.resources = { id: 'test-resources' }

    await server.close()

    expect(server.__closed).toEqual(true)
    expect(listener.close).toBeCalledTimes(1)
    expect(server.listeners).toEqual([])
    expect(server.renderer.close).toBeCalledTimes(1)
    expect(removeAllListeners).toBeCalledTimes(1)
    expect(server.app).toBeNull()
    expect(server.resources).toEqual({})
  })

  test('should prevent closing server multiple times', async () => {
    const removeAllListeners = jest.fn()
    connect.mockReturnValueOnce({ use: jest.fn(), removeAllListeners })
    const nuxt = createNuxt()
    const server = new Server(nuxt)
    server.renderer = {}

    await server.close()

    expect(server.__closed).toEqual(true)
    expect(removeAllListeners).toBeCalledTimes(1)

    removeAllListeners.mockClear()

    await server.close()

    expect(server.__closed).toEqual(true)
    expect(removeAllListeners).not.toBeCalled()
  })
})