@sheerun/jest-express
v1.6.5
Published
jest mock
Downloads
2
Readme
Jest Express
Mock Express for testing with Jest
- express()
- Application
- Request
- baseUrl
- body
- cookies
- fresh
- hostname
- ip
- ips
- method
- originalUrl
- params
- path
- protocol
- query
- route
- baseUrl
- secure
- signedCookies
- stale
- subdomains
- xhr
- accepts()
- acceptsCharsets()
- acceptsEncodings()
- acceptsLanguages()
- get()
- is()
- range()
- setBaseUrl()
- setBody()
- setCookies()
- setFresh()
- setHostname()
- setIp()
- setIps()
- setMethod()
- setOriginalUrl()
- setParams()
- setPath()
- setProtocol()
- setQuery()
- setRoute()
- setSecure()
- setSignedCookies()
- setStale()
- setSubdomains()
- setXhr()
- resetMocked()
- Response
- Router
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]);
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.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.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]);
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.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 [email protected]:jameswlane/jest-express.git
$ cd jest-express
$ npm install
Tests
Linters:
$ npm run tslint
Tests:
$ npm test
Contributing
License
Contributors
Thanks goes to these wonderful people (emoji key):
| James W. Lane III💻 📖 🚇 ⚠️ 🔧 | Adam Stankiewicz🐛 💻 📖 ⚠️ 💡 | Garen Torikian💻 ⚠️ | Konstantin Azizov📖 | | :---: | :---: | :---: | :---: |
This project follows the all-contributors specification. Contributions of any kind welcome!