refactor: use http instead of express

Author: pimlie

package.json

@@ -62,7 +62,7 @@
     "eslint-plugin-promise": "^4.2.1",
     "eslint-plugin-standard": "^4.0.0",
     "eslint-plugin-vue": "^5.2.3",
-    "express": "^4.17.1",
+    "finalhandler": "^1.1.2",
     "geckodriver": "^1.16.2",
     "glob": "^7.1.4",
     "jest": "^24.8.0",
@@ -84,7 +84,6 @@
   "peerDependencies": {
     "browserstack-local": "^1.4.2",
     "chromedriver": "^76.0.0",
-    "express": "^4.17.1",
     "geckodriver": "^1.16.2",
     "jsdom": "^15.1.1",
     "puppeteer": "^1.19.0",

src/utils/commands/static-server.js

@@ -1,13 +1,14 @@
+import http from 'http'
 import { loadDependency } from '..'
 
 export default class StaticServer {
   static async loadDependencies() {
-    if (StaticServer.express) {
+    if (StaticServer.serveStatic) {
       return
     }
 
-    StaticServer.express = await loadDependency('express')
     StaticServer.serveStatic = await loadDependency('serve-static')
+    StaticServer.finalhandler = await loadDependency('finalhandler')
   }
 
   static load(browser) {
@@ -31,22 +32,31 @@ export default class StaticServer {
   static async start(config, quiet) {
     await StaticServer.loadDependencies()
 
-    const app = StaticServer.express()
-
-    app.use(StaticServer.serveStatic(config.folder))
-
     const host = process.env.HOST || config.host || 'localhost'
     const port = process.env.PORT || config.port || 3000
 
-    StaticServer.server = app.listen(port, host)
+    const serve = StaticServer.serveStatic(config.folder)
 
-    if (!quiet) {
-      // eslint-disable-next-line no-console
-      console.info(`tib: Static server started on http://${host}:${port}`)
-    }
+    const server = http.createServer((req, res) => {
+      serve(req, res, StaticServer.finalhandler(req, res))
+    })
+
+    await new Promise((resolve, reject) => {
+      server.on('error', reject)
+      server.listen(port, host, () => {
+        if (!quiet) {
+          // eslint-disable-next-line no-console
+          console.info(`tib: Static server started on http://${host}:${port}`)
+        }
 
-    config.host = host
-    config.port = port
+        config.host = host
+        config.port = port
+
+        StaticServer.server = server
+
+        resolve(server)
+      })
+    })
   }
 
   static stop() {

test/unit/command.static-server.test.js

@@ -1,16 +1,17 @@
-import express from 'express'
+import http from 'http'
+import finalhandler from 'finalhandler'
 import serveStatic from 'serve-static'
 import { loadDependency } from '../../src/utils'
 
-jest.mock('express')
+jest.mock('finalhandler')
 jest.mock('serve-static')
 jest.mock('../../src/utils')
 
 describe('StaticServer', () => {
   let StaticServer
 
   beforeAll(() => {
-    loadDependency.mockImplementation(moduleName => moduleName === 'express' ? express : serveStatic)
+    loadDependency.mockImplementation(moduleName => moduleName === 'finalhandler' ? finalhandler : serveStatic)
   })
 
   beforeEach(async () => {
@@ -25,7 +26,6 @@ describe('StaticServer', () => {
   test('should load dependencies once', async () => {
     expect(StaticServer.express).toBeUndefined()
     await StaticServer.loadDependencies()
-    expect(StaticServer.express).toBeDefined()
     expect(StaticServer.serveStatic).toBeDefined()
 
     expect(loadDependency).toHaveBeenCalledTimes(2)
@@ -68,12 +68,16 @@ describe('StaticServer', () => {
   })
 
   test('should start static server', async () => {
+    const on = jest.fn()
+    const listen = jest.fn((port, host, cb) => cb())
     jest.spyOn(console, 'info').mockImplementation(_ => _)
+    jest.spyOn(http, 'createServer').mockImplementation((fn) => {
+      fn()
+      return { on, listen }
+    })
 
-    const use = jest.fn()
-    const listen = jest.fn()
-    StaticServer.express = jest.fn(() => ({ use, listen }))
-    StaticServer.serveStatic = jest.fn()
+    StaticServer.serveStatic = jest.fn(() => () => {})
+    StaticServer.finalhandler = jest.fn()
 
     const staticServerConfig = {
       folder: 'test-folder',
@@ -83,22 +87,25 @@ describe('StaticServer', () => {
 
     await expect(StaticServer.start(staticServerConfig)).resolves.toBeUndefined()
 
-    expect(StaticServer.express).toHaveBeenCalled()
-    expect(use).toHaveBeenCalled()
+    expect(StaticServer.finalhandler).toHaveBeenCalled()
     expect(StaticServer.serveStatic).toHaveBeenCalledWith(staticServerConfig.folder)
 
-    expect(listen).toHaveBeenCalledWith(staticServerConfig.port, staticServerConfig.host)
+    expect(listen).toHaveBeenCalledWith(staticServerConfig.port, staticServerConfig.host, expect.any(Function))
     // eslint-disable-next-line no-console
     expect(console.info).toHaveBeenCalled()
   })
 
   test('should start static server but not warn when quiet', async () => {
+    const on = jest.fn()
+    const listen = jest.fn((port, host, cb) => cb())
     jest.spyOn(console, 'info').mockImplementation(_ => _)
+    jest.spyOn(http, 'createServer').mockImplementation((fn) => {
+      fn()
+      return { on, listen }
+    })
 
-    const use = jest.fn()
-    const listen = jest.fn()
-    StaticServer.express = jest.fn(() => ({ use, listen }))
-    StaticServer.serveStatic = jest.fn()
+    StaticServer.serveStatic = jest.fn(() => () => {})
+    StaticServer.finalhandler = jest.fn()
 
     const staticServerConfig = {
       folder: 'test-folder',
@@ -108,11 +115,10 @@ describe('StaticServer', () => {
 
     await expect(StaticServer.start(staticServerConfig, true)).resolves.toBeUndefined()
 
-    expect(StaticServer.express).toHaveBeenCalled()
-    expect(use).toHaveBeenCalled()
+    expect(StaticServer.finalhandler).toHaveBeenCalled()
     expect(StaticServer.serveStatic).toHaveBeenCalledWith(staticServerConfig.folder)
 
-    expect(listen).toHaveBeenCalledWith(staticServerConfig.port, staticServerConfig.host)
+    expect(listen).toHaveBeenCalledWith(staticServerConfig.port, staticServerConfig.host, expect.any(Function))
     // eslint-disable-next-line no-console
     expect(console.info).not.toHaveBeenCalled()
   })