Jest Express
Mock Express for testing with Jest
* [json()](#expressjson)
* [static()](#expressstatic)
* [Router()](#expressrouter)
* [urlencoded()](#expressurlencoded)
* [resetMocked()](#resetmocked)* [locals](#applocals)
* [mountpath](#appmountpath)
* [all()](#appall)
* [delete()](#appdelete)
* [disable()](#appdisable)
* [disabled()](#appdisabled)
* [enable()](#appenable)
* [enabled()](#appenabled)
* [engine()](#appengine)
* [get()](#appget)
* [listen()](#applisten)
* [head()](#apphead)
* [post()](#apppost)
* [put()](#appput)
* [connect()](#appconnect)
* [options()](#appoptions)
* [trace()](#apptrace)
* [patch()](#apppatch)
* [param()](#appparam)
* [path()](#apppath)
* [render()](#apprender)
* [route()](#approute)
* [set()](#appset)
* [use()](#appuse)
* [request()](#apprequest)
* [response()](#appresponse)
* [setMountPath()](#appmountpath)
* [setLocals()](#applocals)
* [resetMocked()](#resetmocked)* [baseUrl](#requestbaseUrl)
* [body](#requestbody)
* [cookies](#requestcookies)
* [fresh](#requestfresh)
* [hostname](#requesthostname)
* [ip](#requestip)
* [ips](#requestips)
* [method](#requestmethod)
* [originalUrl](#requestoriginalurl)
* [params](#requestbaseUrl)
* [path](#requestpath)
* [protocol](#requestprotocol)
* [query](#requestquery)
* [route](#requestroute)
* [baseUrl](#requestbaseurl)
* [secure](#requestsecure)
* [signedCookies](#requestsignedcookies)
* [stale](#requeststale)
* [subdomains](#requestsubdomains)
* [xhr](#requestxhr)
* [accepts()](#requestaccepts)
* [acceptsCharsets()](#requestacceptscharsets)
* [acceptsEncodings()](#requestacceptsEncodings)
* [acceptsLanguages()](#requestacceptsLanguages)
* [get()](#requestget)
* [is()](#requestis)
* [range()](#requestrange)
* [setBaseUrl()](#requestsetbaseurl)
* [setBody()](#requestsetbody)
* [setCookies()](#requestsetcookies)
* [setFresh()](#requestsetfresh)
* [setHostname()](#requestsethostname)
* [setHeaders()](#requestsetheaders)
* [setIp()](#requestsetip)
* [setIps()](#requestsetips)
* [setMethod()](#requestsetmethod)
* [setOriginalUrl()](#requestsetoriginalurl)
* [setParams()](#requestsetparams)
* [setPath()](#requestsetpath)
* [setProtocol()](#requestsetprotocol)
* [setQuery()](#requestsetquery)
* [setRoute()](#requestsetroute)
* [setSecure()](#requestsetsecure)
* [setSignedCookies()](#requestsetsignedcookies)
* [setStale()](#requestsetStale)
* [setSubdomains()](#requestsetsubdomains)
* [setXhr()](#requestsetXhr)
* [resetMocked()](#resetmocked)* [headersSent](#responseheaderssent)
* [locals](#responselocals)
* [append()](#responseappend)
* [attachment()](#responseattachment)
* [body](#reponsebody)
* [cookie()](#responsecookie)
* [clearCookie()](#responseclearcookie)
* [download()](#responsedownload)
* [end()](#responseend)
* [format()](#responseformat)
* [get()](#responseget)
* [getHeader()](#responsegetheader)
* [header()](#responseheader)
* [json()](#responsejson)
* [jsonp()](#responsejsonp)
* [links()](#responselinks)
* [location()](#responselocation)
* [redirect()](#responseredirect)
* [render()](#responserender)
* [send()](#responsesend)
* [sendFile()](#responsesendfile)
* [sendStatus()](#responsesendstatus)
* [set()](#responseset)
* [status()](#responsestatus)
* [statusCode]($responsestatuscode)
* [type()](#responsetype)
* [vary()](#responsevary)
* [setHeader()](#responsesetheader)
* [removeHeader()](#responseremoveHeader)
* [setHeadersSent()](#responsesetheaderssent)
* [setLocals()](#responsesetlocals)
* [resetMocked()](#resetmocked)* [request()](#routerrequest)
* [response()](#routerresponse)
* [all()](#routerall)
* [get()](#routerget)
* [param()](#routerparam)
* [route()](#routerroute)
* [use()](#routeruse)
* [resetMocked()](#resetmocked)express()
How to setup Application to use in Jest:jest.mock('express', () => {
return require('jest-express');
});express.json()
Ways to use this API:expect(express.json).toHaveBeenCalledWith([options]);express.static()
Ways to use this API:expect(express.static).toHaveBeenCalledWith(root, [options]);express.Router()
Ways to use this API:expect(express.Router).toHaveBeenCalledWith([options]);express.urlencoded()
Ways to use this API:expect(express.urlencoded).toHaveBeenCalledWith([options]);Application
How to setup Application to use in Jest:import { Express } from 'jest-express/lib/express';
import { server } from '../src/server.js';
let app;
describe('Server', () => {
beforeEach(() => {
app = new Express();
});
afterEach(() => {
app.resetMocked();
});
test('should setup server', () => {
const options = {
port: 3000,
};
server(app, options);
expect(app.set).toBeCalledWith('port', options.port);
});
});app.locals
Ways to use this API:Setup:
beforeEach(() => {
app = new Express();
app.setLocals('title', 'My App');
});app.mountpath
Ways to use this API:Setup:
beforeEach(() => {
app = new Express();
app.setMountPath('/admin');
});app.all()
Ways to use this API:expect(app.all).toBeCalledWith(path, callback [, callback ...]);app.get()
Ways to use this API:expect(app.get).toBeCalledWith(path, callback [, callback ...]);app.head()
Ways to use this API:expect(app.head).toBeCalledWith(path, callback [, callback ...]);app.post()
Ways to use this API:expect(app.post).toBeCalledWith(path, callback [, callback ...]);app.put()
Ways to use this API:expect(app.put).toBeCalledWith(path, callback [, callback ...]);app.delete()
Ways to use this API:expect(app.delete).toBeCalledWith(path, callback [, callback ...]);app.connect()
Ways to use this API:expect(app.connect).toBeCalledWith(path, callback [, callback ...]);app.options()
Ways to use this API:expect(app.options).toBeCalledWith(path, callback [, callback ...]);app.trace()
Ways to use this API:expect(app.trace).toBeCalledWith(path, callback [, callback ...]);app.patch()
Ways to use this API:expect(app.patch).toBeCalledWith(path, callback [, callback ...]);app.param()
Ways to use this API:expect(app.param).toBeCalledWith([name], callback);app.render()
Ways to use this API:expect(app.param).toBeCalledWith(view, [locals], callback);app.use()
Ways to use this API:expect(app.use).toBeCalledWith([path,] callback [, callback...]);Request
How to setup Request to use in Jest:import { Request } from 'jest-express/lib/request';
import { endpoint } from '../src/endpoint.js';
let request;
describe('Endpoint', () => {
beforeEach(() => {
request = new Request('/users?sort=desc', {
headers: {
Accept: 'text/html'
}
});
});
afterEach(() => {
request.resetMocked();
});
test('should setup endpoint', () => {
endpoint(request);
expect(request).toBeCalled();
});
});request.baseUrl
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setBaseUrl(baseUrl);
});request.body
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setBody(body);
});request.cookies
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setCookies(cookies);
});request.fresh
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setFresh(boolean);
});request.hostname
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setHostname(string);
});request.setHeaders
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setHeaders("X-Custom-Header", "foo");
});
// or
beforeEach(() => {
request = new Request();
request.setHeaders({
"X-Custom-Header", "foo",
"X-Custom-Header-2", "bar"
});
});request.ip
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setIp(ip);
});request.ips
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setIps(ips);
});request.method
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setMethod(method);
});request.originalUrl
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setOriginalUrl(originalUrl);
});request.params
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setParams(params);
});request.path
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setPath(path);
});request.protocol
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setProtocol(protocol);
});request.query
You can use it by passing key value pair:Setup:
beforeEach(() => {
request = new Request();
request.setQuery('Accept', 'text/html');
});Or by passing an object:
beforeEach(() => {
request = new Request();
request.setQuery({ 'Accept': 'text/html', 'Accept-Language': 'en' });
});request.route
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setRoute(route);
});request.secure
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setSecure(secure);
});request.signedCookies
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setSignedCookies(signedCookies);
});request.stale
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setStale(boolean);
});request.subdomains
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setSubdomains(subdomains);
});request.xhr
Ways to use this API:Setup:
beforeEach(() => {
request = new Request();
request.setXhr(boolean);
});request.accepts()
Ways to use this API:expect(request.accepts).toBeCalledWith(types);request.acceptsCharsets()
Ways to use this API:expect(request.acceptsCharsets).toBeCalledWith(charset [, ...]);request.acceptsEncodings()
Ways to use this API:expect(request.acceptsEncodings).toBeCalledWith(encoding [, ...]);request.acceptsLanguages()
Ways to use this API:expect(request.acceptsLanguages).toBeCalledWith(lang [, ...]);request.get()
Ways to use this API:expect(request.get).toBeCalledWith(field);request.is()
Ways to use this API:expect(request.is).toBeCalledWith(type);request.param()
Ways to use this API:expect(request.param).toBeCalledWith(name [, defaultValue]);request.range()
Ways to use this API:expect(request.range).toBeCalledWith(size[, options]);Response
How to setup Response to use in Jest:import { Response } from 'jest-express/lib/response';
import { endpoint } from '../src/endpoint.js';
let response;
describe('Endpoint', () => {
beforeEach(() => {
response = new Response();
});
afterEach(() => {
response.resetMocked();
});
test('should setup endpoint', () => {
endpoint(response);
expect(response).toBeCalled();
});
});response.setHeader
Ways to use this API:Setup:
beforeEach(() => {
response = new Response();
response.setHeader(key, value);
expect(response.setHeader).toBeCalledWith(key, value);
});response.removeHeader
Ways to use this API:Setup:
beforeEach(() => {
response = new Response();
response.removeHeader(key);
expect(response.removeHeader).toBeCalledWith(key);
});response.headersSent
Ways to use this API:Setup:
beforeEach(() => {
response = new Response();
response.setHeadersSent(boolean);
});response.locals
Ways to use this API:Setup:
beforeEach(() => {
response = new Response();
response.setLocals('title', 'My App');
});response.append()
Ways to use this API:expect(response.append).toBeCalledWith(field [, value]);response.attachment()
Ways to use this API:expect(response.attachment).toBeCalledWith([filename]);reponse.body
Ways to use this API:expect(response.body).toEqual(value);response.cookie()
Ways to use this API:expect(response.cookie).toBeCalledWith(name, value [, options]);response.clearCookie()
Ways to use this API:expect(response.clearCookie).toBeCalledWith(name [, options]);response.download()
Ways to use this API:expect(response.download).toBeCalledWith(path [, filename] [, options] [, fn]);response.end()
Ways to use this API:expect(response.end).toBeCalledWith([data] [, encoding]);response.format()
Ways to use this API:expect(response.format).toBeCalledWith(object);response.get()
Ways to use this API:expect(response.get).toBeCalledWith(field);response.getHeader()
Ways to use this API:response.setHeader('Accept', 'text/html')
expect(response.getHeader('Accept')).toEqual('text/html');response.header()
An alias for response.set()expect(response.header).toBeCalledWith(field, [value]);response.json()
Ways to use this API:expect(response.json).toBeCalledWith([body]);response.jsonp()
Ways to use this API:expect(response.jsonp).toBeCalledWith([body]);response.links()
Ways to use this API:expect(response.links).toBeCalledWith(links);response.location()
Ways to use this API:expect(response.location).toBeCalledWith(path);response.redirect()
Ways to use this API:expect(response.redirect).toBeCalledWith([status,] path);response.render()
Ways to use this API:expect(response.render).toBeCalledWith(view [, locals] [, callback]);response.send()
Ways to use this API:expect(response.send).toBeCalledWith([body]);response.sendFile()
Ways to use this API:expect(response.sendFile).toBeCalledWith(path [, options] [, fn]);response.sendStatus()
Ways to use this API:expect(response.sendStatus).toBeCalledWith(statusCode);response.set()
Sets headers. It is calling response.setHeader() internally.expect(response.set).toBeCalledWith(field [, value]);response.status()
Ways to use this API:expect(response.status).toBeCalledWith(code);response.statusCode
ways to use this API:
expect(response.statusCode).toEqual(code);response.type()
Ways to use this API:expect(response.type).toBeCalledWith(type);response.vary()
Ways to use this API:expect(response.vary).toBeCalledWith(field);Router
How to setup Response to use in Jest:import { Router } from 'jest-express/lib/router';
import { endpoint } from '../src/endpoint.js';
let router;
describe('Endpoint', () => {
beforeEach(() => {
router = new Router();
});
afterEach(() => {
router.resetMocked();
});
test('should setup endpoint', () => {
endpoint(router);
expect(router).toBeCalled();
});
});router.all()
Ways to use this API:expect(router.all).toBeCalledWith(path, [callback, ...] callback);router.get()
Ways to use this API:expect(router.get).toBeCalledWith(path, [callback, ...] callback);router.param()
Ways to use this API:expect(router.param).toBeCalledWith(name, callback);router.route()
Ways to use this API:expect(router.route).toBeCalledWith(path);router.use()
Ways to use this API:expect(router.use).toBeCalledWith([path], [function, ...] function);resetMocked()
Resets all information stored in the mock, including any initial implementation and mock name given.This is useful when you want to completely restore a mock back to its initial state.
Development
Setup
$ git clone git@github.com:jameswlane/jest-express.git
$ cd jest-express
$ npm installTests
Linters:$ npm run tslintTests:
$ npm testContributing
License
Contributors
Thanks goes to these wonderful people (emoji key):This project follows the all-contributors specification. Contributions of any kind welcome!
