promise-ax/test/app.spec.js

Promise Ax (Promesa) es usado para computaciones asíncronas. Una promesa representa un valor que puede estar disponible ahora, en el futuro, o nunca.

const { createPromise } = require('../app.js');
describe("Test Case iterative.promise.js", () => {
    const asyncOperation = (time) => {
        return new Promise((resolve, reject) => {
            if (time < 0 || time === 3_001) {
                setTimeout(() => {
                    reject("reject");
                }, time);
            } else {
                setTimeout(() => {
                    resolve(time);
                }, time);
            }
        });
    };
    it("test #1 => allSettled", async () => {
        const promisesToMake = [
            asyncOperation(2000),
            asyncOperation(1000),
            asyncOperation(500),
            asyncOperation(-500)];
        const promise = createPromise();
        let results = await promise.allSettled(promisesToMake);
        expect(results[0]).toBe(2000);
    });
    it("test #2 => allSettled with timeout", async () => {
        const promisesToMake = [
            asyncOperation(2000),
            asyncOperation(1000),
            asyncOperation(500),
            asyncOperation(-500)];
        const promise = createPromise();
        let results = await promise.allSettledWithTimeOut(promisesToMake, 500);
        expect(results[0]).toBeInstanceOf(Error);
    });
    it("test #3 => allSettled with timeout and message", async () => {
        const promisesToMake = [
            asyncOperation(2000),
            asyncOperation(1000),
            asyncOperation(500),
            asyncOperation(-500)];
        const promise = createPromise();
        let results = await promise.allSettledWithTimeOut(promisesToMake, 500, "timeoutError");
        expect(results[0].message).toBe("timeoutError");
    });
    it("test #4 => allSettled with real time", async () => {
        const promise = createPromise();
        const promisesToMake = [
            asyncOperation(2000),
            asyncOperation(1000),
            asyncOperation(500),
            asyncOperation(-500)];
        const startTime = new Date().getTime();
        await promise.allSettled(promisesToMake);
        const diffTime = new Date().getTime() - startTime;
        expect(diffTime).toBeGreaterThanOrEqual(1900);
        expect(diffTime).toBeLessThan(2500);
    });
    it("test #5 => allSettled", async () => {
        const promise = createPromise();
        const promisesToMake = [
            asyncOperation(2000),
            asyncOperation(1000),
            promise.resolve("resolve"),
            promise.reject("reject"),
            asyncOperation(3_001),
        ];
        let results = await promise.allSettled(promisesToMake);
        expect(results[0]).toBe(2000);
        expect(results[1]).toBe(1000);
        expect(results[2]).toBe("resolve");
        expect(results[3]).toBe("reject");
        expect(results[4]).toBe("reject");
    });
    it("test #6 => allSettled empty", async () => {
        const promise = createPromise();
        const promisesToMake = [];
        let results = await promise.allSettled(promisesToMake);
        expect(results.length).toBe(0);
    });
    it("test #7 => all", async () => {
        try {
            const promise = createPromise();
            const promisesToMake = [
                asyncOperation(2000),
                asyncOperation(1000),
                asyncOperation(-400),
                promise.resolve("resolve"),
                promise.reject("reject"),
            ];
            let results = await promise.all(promisesToMake);
            expect(results[0]).toBe(2000);
        } catch (error) {
            expect(error).toBe("reject");
        }
    });
    it("test #8 => all empty", async () => {
        try {
            const promise = createPromise();
            const promisesToMake = [];
            let results = await promise.all(promisesToMake);
            expect(results.length).toBe(0);
        } catch (error) {
            expect(error).toBe("reject");
        }
    });
    it("test #9 => resolve", async () => {
        try {
            const promise = createPromise();
            let results = await promise.resolve(asyncOperation(2000));
            expect(results[0]).toBe(2000);
        } catch (error) {
            expect(error).toBeInstanceOf(Error);
        }
    });
    it("test #10 => reject", async () => {
        try {
            const promise = createPromise();
            let results = await promise.reject("reject");
            expect(results[0]).toBe(2000);
        } catch (error) {
            expect(error).toBe("reject");
        }
    });
    it("test #11 => race", async () => {
        try {
            const promise = createPromise();
            let results = await promise.race([asyncOperation(2000), asyncOperation(500)]);
            expect(results[0]).toBe(500);
        } catch (error) {
            expect(error).toBeInstanceOf(Error);
        }
    });
});