resolvable-promise/dist/cjs/resolable.test.js

Promises with the resolve and reject functions exposed

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const chai_1 = __importDefault(require("chai"));
const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
const resolvable_1 = __importDefault(require("./resolvable"));
chai_1.default.use(chai_as_promised_1.default);
const { expect } = chai_1.default;
describe('Resolvable', () => {
    it('should be instantiable as a class (2.0 style)', () => {
        expect(new resolvable_1.default()).to.not.be.undefined;
    });
    it('should be instantiable as a function (1.0 style)', () => {
        const makeResolvable = resolvable_1.default;
        expect(makeResolvable()).to.not.be.undefined;
    });
    it('should be an instance of Promise', () => {
        expect(new resolvable_1.default()).to.be.instanceof(Promise);
    });
    it('should resolve when called with external resolve function', async () => {
        let externalResolveCalled = false;
        const resolvable = new resolvable_1.default();
        setImmediate(() => {
            externalResolveCalled = true;
            resolvable.resolve();
        });
        await resolvable;
        expect(externalResolveCalled).to.be.true;
        await expect(resolvable).to.be.fulfilled;
    });
    it('should reject when called with external reject function', async () => {
        const resolvable = new resolvable_1.default();
        setImmediate(() => {
            resolvable.reject(new Error());
        });
        await expect(resolvable).to.be.rejected;
    });
    it('should return resolved value when called with external resolve function', async () => {
        const resolvable = new resolvable_1.default();
        resolvable.resolve(42);
        await expect(resolvable).to.eventually.equal(42);
    });
    it('should reject with given error when called with external reject function', async () => {
        const resolvable = new resolvable_1.default();
        const error = new Error('test');
        resolvable.reject(error);
        await expect(resolvable).to.be.rejectedWith(error);
    });
    it('should behave as parent promise when given a promise as constructor argument', async () => {
        const resolvingResolvable = new resolvable_1.default(Promise.resolve(42));
        await expect(resolvingResolvable).to.eventually.equal(42);
        const rejectingResolvable = new resolvable_1.default(Promise.reject(new Error('test')));
        await expect(rejectingResolvable).to.be.rejected;
    });
    it('should behave as promise if given promise executor function as constructor argument', async () => {
        const resolvingResolvable = new resolvable_1.default(resolve => {
            resolve(42);
        });
        await expect(resolvingResolvable).to.eventually.equal(42);
        const rejectingResolvable = new resolvable_1.default((resolve, reject) => {
            reject(new Error('test'));
        });
        await expect(rejectingResolvable).to.be.rejected;
    });
});
//# sourceMappingURL=resolable.test.js.map