feat: freeze proto to work with express (#67)

* feat: freeze proto to work with express

* feat: conditionally fix proto methods for express mode

* test: add express tests, run all test in test folder

* chore: delete unused test

* chore: typo

* pr feedback

* fixProto -> freezeProto

* doc: update for express mode

Author: salmanm

.gitignore

@@ -57,4 +57,6 @@ package-lock.json
 
 # generated code
 examples/typescript-server.js
-test/type/index.js 
+test/type/index.js
+
+.vscode

README.md

@@ -4,8 +4,8 @@
 
 [![Build Status](https://travis-ci.org/fastify/light-my-request.svg?branch=master)](https://travis-ci.org/fastify/light-my-request) [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)
 
-Injects a fake HTTP request/response into a node HTTP server for simulating server logic, writing tests, or debugging.  
-Does not use a socket connection so can be run against an inactive server (server not in listen mode).  
+Injects a fake HTTP request/response into a node HTTP server for simulating server logic, writing tests, or debugging.
+Does not use a socket connection so can be run against an inactive server (server not in listen mode).
 
 ## Example
 
@@ -131,6 +131,26 @@ The declaration file exports types for the following parts of the API:
 - `Request` - custom light-my-request `request` object interface. Extends Node.js `stream.Readable` type
 - `Response` - custom light-my-request `response` object interface. Extends Node.js `http.ServerResponse` type
 
+### Example with Express
+
+```javascript
+const http = require('http')
+const inject = require('light-my-request')
+
+const dispatch = function (req, res) {
+  const reply = 'Hello World'
+  res.writeHead(200, { 'Content-Type': 'text/plain', 'Content-Length': reply.length })
+  res.end(reply)
+}
+
+const server = http.createServer(dispatch)
+
+inject(dispatch, { method: 'get', url: '/', express: true }, (err, res) => {
+  console.log(res.payload)
+})
+```
+Note the `express: true` in the above example. This flag makes sure that we still get the correct behaviour with express framework.
+
 ## API
 
 #### `inject(dispatchFunc[, options, callback])`
@@ -159,6 +179,7 @@ Injects a fake request into an HTTP server.
   - `server` - Optional http server. It is used for binding the `dispatchFunc`.
   - `autoStart` - Automatically start the request as soon as the method
     is called. It is only valid when not passing a callback. Defaults to `true`.
+  - `express` - A boolean flag to enable working with express framework. By default express doesn't support request injection, this enforces.
 - `callback` - the callback function using the signature `function (err, res)` where:
   - `err` - error object
   - `res` - a response object where:
@@ -225,8 +246,8 @@ inject(dispatch)
 Note: The application would not respond multiple times. If you try to invoking any method after the application has responded, the application would throw an error.
 
 ## Acknowledgements
-This project has been forked from [`hapi/shot`](https://github.com/hapijs/shot) because we wanted to support *Node ≥ v4* and not only *Node ≥ v8*.  
-All the credits before the commit [00a2a82](https://github.com/fastify/light-my-request/commit/00a2a82eb773b765003b6085788cc3564cd08326) goes to the `hapi/shot` project [contributors](https://github.com/hapijs/shot/graphs/contributors).  
+This project has been forked from [`hapi/shot`](https://github.com/hapijs/shot) because we wanted to support *Node ≥ v4* and not only *Node ≥ v8*.
+All the credits before the commit [00a2a82](https://github.com/fastify/light-my-request/commit/00a2a82eb773b765003b6085788cc3564cd08326) goes to the `hapi/shot` project [contributors](https://github.com/hapijs/shot/graphs/contributors).
 Since the commit [db8bced](https://github.com/fastify/light-my-request/commit/db8bced10b4367731688c8738621d42f39680efc) the project will be maintained by the Fastify team.
 
 ## License

index.d.ts

@@ -57,6 +57,7 @@ declare namespace LightMyRequest {
     validate?: boolean
     payload?: InjectPayload
     server?: http.Server
+    express?: boolean
   }
 
   interface Request extends stream.Readable {

index.js

@@ -5,6 +5,7 @@ const http = require('http')
 const Ajv = require('ajv')
 const Request = require('./lib/request')
 const Response = require('./lib/response')
+const freezeProto = require('./util')
 
 const errorMessage = 'The dispatch function has already been invoked'
 const urlSchema = {
@@ -82,18 +83,29 @@ function doInject (dispatchFunc, options, callback) {
     }
   }
 
+  const express = options.express
   const server = options.server || {}
 
   if (typeof callback === 'function') {
     const req = new Request(options)
     const res = new Response(req, callback)
 
+    if (express) {
+      freezeProto(req)
+      freezeProto(res)
+    }
+
     return req.prepare(() => dispatchFunc.call(server, req, res))
   } else {
     return new Promise((resolve, reject) => {
       const req = new Request(options)
       const res = new Response(req, resolve, reject)
 
+      if (express) {
+        freezeProto(req)
+        freezeProto(res)
+      }
+
       req.prepare(() => dispatchFunc.call(server, req, res))
     })
   }

package.json

@@ -10,6 +10,7 @@
   "types": "index.d.ts",
   "devDependencies": {
     "@types/node": "^12.11.6",
+    "express": "^4.17.1",
     "form-data": "^3.0.0",
     "pre-commit": "^1.2.2",
     "standard": "^14.0.2",
@@ -19,7 +20,7 @@
   "scripts": {
     "test": "npm run lint && npm run unit && npm run tsd",
     "lint": "standard",
-    "unit": "tap test/test.js",
+    "unit": "tap test/**.test.js",
     "coverage": "npm run unit -- --cov --coverage-report=html",
     "tsd": "tsd"
   },

test/express.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const test = require('tap').test
+const express = require('express')
+
+const inject = require('../index')
+
+test('works with express with callback', (t) => {
+  t.plan(8)
+
+  const app = express()
+
+  app.get('/', (req, res) => {
+    res.send({ ok: true, path: '/' })
+  })
+
+  app.get('/blah', (req, res) => {
+    res.send({ ok: true, path: '/blah' })
+  })
+
+  inject(app, { url: '/', express: true }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.deepEqual(res.json(), { ok: true, path: '/' })
+  })
+
+  inject(app, { url: '/blah', express: true }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.deepEqual(res.json(), { ok: true, path: '/blah' })
+  })
+
+  inject(app, { url: '/bad-path', express: true }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 404)
+  })
+})
+
+test('works with express with promise', (t) => {
+  t.plan(5)
+
+  const app = express()
+
+  app.get('/', (req, res) => {
+    res.send({ ok: true, path: '/' })
+  })
+
+  app.get('/blah', (req, res) => {
+    res.send({ ok: true, path: '/blah' })
+  })
+
+  inject(app, { url: '/', express: true }).then((res) => {
+    t.equal(res.statusCode, 200)
+    t.deepEqual(res.json(), { ok: true, path: '/' })
+  })
+
+  inject(app, { url: '/blah', express: true }).then((res) => {
+    t.equal(res.statusCode, 200)
+    t.deepEqual(res.json(), { ok: true, path: '/blah' })
+  })
+
+  inject(app, { url: '/bad-path', express: true }).then((res) => {
+    t.equal(res.statusCode, 404)
+  })
+})

test/test.js test/index.test.jstest/test.js renamed to test/index.test.js

@@ -0,0 +1,20 @@
+/**
+ * This is needed for express as it replaces our prototype.
+ * https://github.com/expressjs/express/blob/master/lib/middleware/init.js#L36
+ * Which is why we loose our overridden prototype methods.
+ * This function ensures that those remain intact.
+ *
+ * @param instance
+ */
+function freezeProto (instance) {
+  Object.keys(Object.getPrototypeOf(instance)).forEach((method) => {
+    Object.defineProperty(instance, method, {
+      writable: false,
+      configurable: false,
+      readable: true,
+      value: instance[method]
+    })
+  })
+}
+
+module.exports = freezeProto