Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

es2015-deferred

Package Overview
Dependencies
Maintainers
1
Versions
10
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

es2015-deferred

A tiny constructor for deferred objects. Useful for stubbing promises in tests.

  • 4.0.2
  • latest
  • Source
  • npm
  • Socket score

Version published
Weekly downloads
13
increased by8.33%
Maintainers
1
Weekly downloads
 
Created
Source

ES2015 Deferred

This library contains a small constructor which produces deferred objects. These are useful for testing purposes, and their use in production JS is discouraged (it's usually better to use the promise constructor directly).

This module has no production dependencies.

installation

npm i es2015-deferred

ES2015

ES2015 module loaders can directly consume index.js. If you're using rollup or another ES2015 compatible module loader configured to look for the module field and in a package.json file, then you can import with:

import Deferred from 'es2015-deferred';

The @rollup/plugin-node-resolve package may be useful to you.

If you want to try this module out directly without installation, it can be used via unpkg:

import Deferred from 'https://unpkg.com/es2015-deferred?module';

API

With Deferred in your environment you can create deferred objects.

var deferred = new Deferred();

// new is optional...

var deferred = Deferred();

A promise is managed by the deferred object.

var promise = deferred.promise;

Resolve deferred.promise with a given value.

deferred.resolve('a-resolution');

Reject deferred.promise with an error.

deferred.reject(new Error('Oh noes!'));

Resolve and reject return the promise for easy chaining, e.g.

deferred.resolve('a-resolution').then(/* ... */);

example

This module is intended for use with unit test runners like mocha. Let's say you want to test a module which makes a request using fetch and parses the response as JSON:

export default function fetchAndParse(url) {
  return self.fetch(url).then(response => {
    if (!response.ok) {
      throw new Error(`Unexpected response: ${response.status}`);
    }

    return response.json();
  });
}

Fetch uses promises, so testing it can be tricky! Here's a set of tests for this module written in mocha and sinon. What follows is bulky, but exhaustive. It can be surprising how much branching promises hide!

import assert from 'assert';
import sinon from 'sinon';
import fetchAndParse from './fetchAndParse';

// For failing tests on promises which should reject but do not.
function failResolve() {
  throw new Error('Promise should reject.');
}

describe('fetchAndParse', () => {
  const sandbox = sinon.sandbox.create();

  let fetchDeferred;
  let promise;

  beforeEach(() => {
    fetchDeferred = new Deferred();

    // Stub fetch with a function which returns a promise we control.
    sandbox.stub(self, 'fetch').returns(fetchDeferred.promise);

    // Using a deferred above means we can use this promise throughout
    // the tests, resolve or rejecting steps as we go along. A deferred
    // allows test cases to be built progressively as describe nest.
    promise = fetchAndParse('some-url');
  });

  afterEach(() => {
    sandbox.reset();
  });

  it('calls fetch with the given url', () => {
    assert.equal(self.fetch.callCount, 1);
    assert.ok(self.fetch.calledWithExactly('some-url'));
  });

  describe('when the call to fetch rejects', () => {
    let error;

    beforeEach(() => {
      error = new Error();

      // By rejecting here, the promise set up above gets is rejected.
      fetchDeferred.reject(error);
    });

    it('rejects the promise returned from fetchAndParse with the same error', () => {
      // Mocha treats a resolved promise as a success. This line
      // converts and checks rejected promises to resolved, and turns
      // resolve promises to rejections before returning for mocha.
      return promise.then(
        failResolve,
        err => assert.equal(err, error)
      );
    });
  });

  describe('when the call to fetch resolves with an unsuccessful status', () => {
    beforeEach(() => {
      // Fetch resolves to a response object. Instruct the deferred
      // object to follow that behaviour.
      fetchDeferred.resolve({
        ok: false,
        status: 404
      });
    });

    it('rejects with an unexpected response error', () => {
      return promise.then(failResolve, err => {
        assert.ok(err instanceof Error);
        assert.equal(err.message, 'Unexpected response: 404');
      });
    });
  });

  describe('when the call to fetch resolves with a successful status', () => {
    let jsonDeferred;
    let response;

    beforeEach(() => {
      // The json method of the response returns a promise. Use a deferred
      // object to manage that.
      jsonDeferred = new Deferred();

      response = {
        ok: true,
        json: sansbox.stub().returns(jsonDeferred.promise);
      };

      fetchDeferred.resolve(response);
    });

    it('calls the json method of the response object', () => {
      return fetchDeferred.promise.then(() => assert.equal(response.json.callCount, 1));
    });

    describe('when response.json rejects', () => {
      let error;

      beforeEach(() => {
        error = new Error();

        jsonDeferred.reject(error);
      });

      it('rejects the promise returned from fetchAndParse with the same error', () => {
        return promise.then(
          failResolve,
          err => assert.equal(err, error)
        );
      });
    });

    describe('when response.json resolves', () => {
      beforeEach(() => {
        jsonDeferred.resolve('parsed-response-body')
      });

      it('resolves the promise returned from fetchAndParse with the result', () => {
        return promise.then(result => assert.equal(result, 'parsed-response-body'));
      });
    });
  });
});

Keywords

FAQs

Package last updated on 03 Aug 2021

Did you know?

Socket

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.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc