jest-express
Advanced tools
Mock Express for testing with Jest
Other
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]);
ApplicationHow 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.localsWays to use this API:
Setup:
beforeEach(() => {
app = new Express();
app.setLocals('title', 'My App');
});
app.mountpathWays 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...]);
RequestHow 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.baseUrlWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setBaseUrl(baseUrl);
});
request.bodyWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setBody(body);
});
request.cookiesWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setCookies(cookies);
});
request.freshWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setFresh(boolean);
});
request.hostnameWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setHostname(string);
});
request.setHeadersWays 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.ipWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setIp(ip);
});
request.ipsWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setIps(ips);
});
request.methodWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setMethod(method);
});
request.originalUrlWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setOriginalUrl(originalUrl);
});
request.paramsWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setParams(params);
});
request.pathWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setPath(path);
});
request.protocolWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setProtocol(protocol);
});
request.queryYou 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.routeWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setRoute(route);
});
request.secureWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setSecure(secure);
});
request.signedCookiesWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setSignedCookies(signedCookies);
});
request.staleWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setStale(boolean);
});
request.subdomainsWays to use this API:
Setup:
beforeEach(() => {
request = new Request();
request.setSubdomains(subdomains);
});
request.xhrWays 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]);
ResponseHow 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.setHeaderWays to use this API:
Setup:
beforeEach(() => {
response = new Response();
response.setHeader(key, value);
expect(response.setHeader).toBeCalledWith(key, value);
});
response.removeHeaderWays to use this API:
Setup:
beforeEach(() => {
response = new Response();
response.removeHeader(key);
expect(response.removeHeader).toBeCalledWith(key);
});
response.headersSentWays to use this API:
Setup:
beforeEach(() => {
response = new Response();
response.setHeadersSent(boolean);
});
response.localsWays 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.bodyWays 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.statusCodeways 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);
RouterHow 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.
$ git clone git@github.com:jameswlane/jest-express.git
$ cd jest-express
$ npm install
Linters:
$ npm run tslint
Tests:
$ npm test
Thanks goes to these wonderful people (emoji key):
This project follows the all-contributors specification. Contributions of any kind welcome!
FAQs
jest mock
We found that jest-express demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.
Security News
The Ultralytics' PyPI Package was compromised four times in one weekend through GitHub Actions cache poisoning and failure to rotate previously compromised API tokens.
Security News
Research
Socket researchers found a malicious Maven package impersonating the legitimate ‘XZ for Java’ library, introducing a backdoor for remote code execution.
