Skip to content
Mock Express for testing with Jest
TypeScript JavaScript
Branch: master
Clone or download
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.circleci Removed audit Jul 6, 2019
.github Update FUNDING.yml May 29, 2019
src feat(Response): add 'responseHeader' method Jan 16, 2020
test feat(Response): add 'responseHeader' method Jan 16, 2020
.all-contributorsrc feat(Response): add 'responseHeader' method Jan 16, 2020
.codeclimate.yml
.gitignore chore(package): Updated typescript to version 3.2.2 Dec 11, 2018
.npmignore
.npmrc Create .npmrc May 29, 2019
.nvmrc fix(Node) Updated default node version May 3, 2019
CHANGELOG.md fix(application): Initial Commit Feb 11, 2018
CODE_OF_CONDUCT.md Create CODE_OF_CONDUCT.md Feb 11, 2018
CONTRIBUTING.md docs(CONTRIBUTING.md): Updated the verify command in docs Sep 18, 2018
ISSUE_TEMPLATE.md feat(ISSUE_TEMPLATE.md): Replaced react for jest-express in template Sep 18, 2018
LICENSE Initial commit Feb 11, 2018
PULL_REQUEST_TEMPLATE.md Create PULL_REQUEST_TEMPLATE.md Feb 11, 2018
README.md feat(Response): add 'responseHeader' method Jan 16, 2020
codecov.yml fix(application): Initial Commit Feb 11, 2018
commitlint.config.js fix(application): Initial Commit Feb 11, 2018
jest.config.js test(ts-jest): Fixed Jest test runner Oct 15, 2018
lint-staged.config.js fix(application): Initial Commit Feb 11, 2018
package.json Merge pull request #417 from jameswlane/dependabot/npm_and_yarn/codec… Feb 10, 2020
tsconfig.json build(TypeScript): Added jest to the tsconfig Jan 17, 2019
tslint.json fix(application): Initial Commit Feb 11, 2018

README.md

Jest Express

All Contributors CircleCI dependencies Status Maintainability Test Coverage codecov devDependencies Status Downloads/week

Waffle.io - Columns and their card count

Mock Express for testing with Jest

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]);

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 git@github.com: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

📖

dozenne

💻 ⚠️

László Székely-Tóth

💻 ⚠️

mattmarcello

💻 ⚠️

Harshith Keni

💻

Max Holman

💻 ⚠️

Matthew Alsup

💻

ttxndrx

💻

Ben Bakhar

💻 ⚠️ 📖

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

You can’t perform that action at this time.