Jest Express

Mock Express for testing with Jest

• express()
  • json()
  • static()
  • Router()
  • urlencoded()
  • resetMocked()
• Application
  • locals
  • mountpath
  • all()
  • delete()
  • disable()
  • disabled()
  • enable()
  • enabled()
  • engine()
  • get()
  • listen()
  • head()
  • post()
  • put()
  • connect()
  • options()
  • trace()
  • patch()
  • param()
  • path()
  • render()
  • route()
  • set()
  • use()
  • request()
  • response()
  • setMountPath()
  • setLocals()
  • resetMocked()
• 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()
  • setHeaders()
  • setIp()
  • setIps()
  • setMethod()
  • setOriginalUrl()
  • setParams()
  • setPath()
  • setProtocol()
  • setQuery()
  • setRoute()
  • setSecure()
  • setSignedCookies()
  • setStale()
  • setSubdomains()
  • setXhr()
  • resetMocked()
• Response
  • headersSent
  • locals
  • append()
  • attachment()
  • body
  • cookie()
  • clearCookie()
  • download()
  • end()
  • format()
  • get()
  • getHeader()
  • header()
  • json()
  • jsonp()
  • links()
  • location()
  • redirect()
  • render()
  • send()
  • sendFile()
  • sendStatus()
  • set()
  • status()
  • statusCode
  • type()
  • vary()
  • setHeader()
  • removeHeader()
  • setHeadersSent()
  • setLocals()
  • resetMocked()
• Router
  • request()
  • response()
  • all()
  • get()
  • param()
  • route()
  • use()
  • resetMocked()

Other

1. Development
2. Contributing
3. License

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 [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):

This project follows the all-contributors specification. Contributions of any kind welcome!