jest-express
Advanced tools
Readme
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
The npm package jest-express receives a total of 29,887 weekly downloads. As such, jest-express popularity was classified as popular.
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.
Security News
NIST's new AI Risk Management Framework aims to enhance the security and reliability of generative AI systems and address the unique challenges of malicious AI exploits.
Security News
This episode of the Risky Biz podcast discusses how the rise of small open source packages and the shift towards individual maintainers makes the ecosystem more vulnerable to supply chain attacks.
Product
Streamline your login process and enhance security by enabling Single Sign-On (SSO) on the Socket platform, now available for all customers on the Enterprise plan, supporting 20+ identity providers.
