Nuclear Pumpkin Mayhem

    jest-express
    TypeScript icon, indicating that this package has built-in type declarations

    1.12.0 • Public • Published

    Jest Express

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

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

    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 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

    💻 ⚠️ 📖

    Ronald J Kimball

    💻 ⚠️

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

    Install

    npm i jest-express

    DownloadsWeekly Downloads

    42,163

    Version

    1.12.0

    License

    MIT

    Unpacked Size

    175 kB

    Total Files

    46

    Last publish

    Collaborators

    • james.w.lane