light-my-request

What is light-my-request?

The light-my-request npm package is a lightweight HTTP request simulation tool designed primarily for testing purposes. It allows developers to simulate HTTP requests to their Node.js applications without the need for a real server. This is particularly useful for testing route handlers and middleware in isolation.

What are light-my-request's main functionalities?

Simulate HTTP GET Request

This feature allows you to simulate an HTTP GET request to a given handler function. The response can then be inspected to verify the behavior of the handler.

const { inject } = require('light-my-request');
const handler = (req, res) => { res.end('Hello, world!'); };

inject(handler, { method: 'GET', url: '/' }, (err, res) => {
  console.log(res.payload); // 'Hello, world!'
});

Simulate HTTP POST Request with Payload

This feature allows you to simulate an HTTP POST request with a payload. The handler can process the payload, and the response can be inspected to verify the behavior.

const { inject } = require('light-my-request');
const handler = (req, res) => {
  let body = '';
  req.on('data', chunk => { body += chunk; });
  req.on('end', () => { res.end(`Received: ${body}`); });
};

inject(handler, { method: 'POST', url: '/', payload: 'Hello, world!' }, (err, res) => {
  console.log(res.payload); // 'Received: Hello, world!'
});

Simulate HTTP Request with Headers

This feature allows you to simulate an HTTP request with custom headers. The handler can access these headers, and the response can be inspected to verify the behavior.

const { inject } = require('light-my-request');
const handler = (req, res) => {
  res.end(`Header: ${req.headers['x-custom-header']}`);
};

inject(handler, { method: 'GET', url: '/', headers: { 'x-custom-header': 'test-value' } }, (err, res) => {
  console.log(res.payload); // 'Header: test-value'
});

Other packages similar to light-my-request

supertest

Supertest is a popular HTTP assertion library that works with any test framework. It allows you to test HTTP endpoints by making requests and asserting on the responses. Compared to light-my-request, Supertest is more feature-rich and integrates well with various testing frameworks like Mocha and Jest.

nock

Nock is an HTTP mocking and expectations library for Node.js. It allows you to intercept HTTP requests and provide predefined responses, making it useful for testing HTTP clients. Unlike light-my-request, which focuses on simulating requests to handlers, Nock is more about mocking external HTTP requests.

axios-mock-adapter

Axios-mock-adapter is a library that allows you to mock requests made using the Axios HTTP client. It provides a way to define how requests should be handled and what responses should be returned. This is different from light-my-request, which is more focused on simulating requests to server handlers rather than mocking client-side requests.

README

Light my Request

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

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: '/' }, (res) => {
  console.log(res.payload)
})

Note how server.listen is never called.

Async await and promises are supported as well!

// promises
inject(dispatch, { method: 'get', url: '/' })
  .then(res => console.log(res.payload))

// async-await
const res = await inject(dispatch, { method: 'get', url: '/' })
console.log(res.payload)

API

inject(dispatchFunc, options, callback)

Injects a fake request into an HTTP server.

• dispatchFunc - listener function. The same as you would pass to Http.createServer when making a node HTTP server. Has the signature function (req, res) where:
  • req - a simulated request object. Inherits from Stream.Readable.
  • res - a simulated response object. Inherits from node's Http.ServerResponse.
• options - request options object where:
  • url - a string specifying the request URL.
  • method - a string specifying the HTTP request method, defaulting to 'GET'.
  • authority - a string specifying the HTTP HOST header value to be used if no header is provided, and the url does not include an authority component. Defaults to 'localhost'.
  • headers - an optional object containing request headers.
  • remoteAddress - an optional string specifying the client remote address. Defaults to '127.0.0.1'.
  • payload - an optional request payload. Can be a string, Buffer, Stream or object.
  • simulate - an object containing flags to simulate various conditions:
    • end - indicates whether the request will fire an end event. Defaults to undefined, meaning an end event will fire.
    • split - indicates whether the request payload will be split into chunks. Defaults to undefined, meaning payload will not be chunked.
    • error - whether the request will emit an error event. Defaults to undefined, meaning no error event will be emitted. If set to true, the emitted error will have a message of 'Simulated'.
    • close - whether the request will emit a close event. Defaults to undefined, meaning no close event will be emitted.
  • validate - Optional flag to validate this options object. Defaults to true.
  • server - Optional http server. It is used for binding the dispatchFunc.
• callback - the callback function using the signature function (res) where:
  • res - a response object where:
    • raw - an object containing the raw request and response objects where:
      • req - the simulated request object.
      • res - the simulated response object.
    • headers - an object containing the response headers.
    • statusCode - the HTTP status code.
    • statusMessage - the HTTP status message.
    • payload - the payload as a UTF-8 encoded string.
    • rawPayload - the raw payload as a Buffer.
    • trailers - an object containing the response trailers.

inject.isInjection(obj)

Checks if given object obj is a Shot Request object.

Acknowledgements

This project has been forked from hapi/shot because we wanted to support Node ≥ v4 and not only Node ≥ v8.
All the credits before the commit 00a2a82 goes to the hapi/shot project contributors.
Since the commit db8bced the project will be maintained by the Fastify team.

License

Licensed under BSD-3-Clause.