electron-rpc-async-queue/dist/Task.unit.js

Async queue implementation for Electron RPC

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const assert = __importStar(require("assert"));
const Task_1 = require("./Task");
const TaskEventType_1 = require("./TaskEventType");
// Constants
const TEST_ERROR_MESSAGE = 'Test error';
const DELAY = 500;
// Helpers
const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
const makeSyncTask = (throwsError) => new Task_1.Task(throwsError
    ? () => {
        throw new Error(TEST_ERROR_MESSAGE);
    }
    : () => void 0);
const makeAsyncTask = (throwsError) => new Task_1.Task(throwsError
    ? async () => {
        await sleep(DELAY);
        throw new Error(TEST_ERROR_MESSAGE);
    }
    : async () => {
        await sleep(DELAY);
    });
const getTestCaseDescription = (isAsync, throwsError) => `${isAsync ? 'Async' : 'Sync'} task${throwsError ? ' with error' : ''}`;
const createEventsTestCase = (isAsync, throwsError) => {
    it(`${getTestCaseDescription(isAsync, throwsError)} events`, async () => {
        const task = isAsync ? makeAsyncTask(throwsError) : makeSyncTask(throwsError);
        const events = [];
        task.on(TaskEventType_1.TaskEventType.START, () => {
            events.push(TaskEventType_1.TaskEventType.START);
        });
        task.on(throwsError ? TaskEventType_1.TaskEventType.ERROR : TaskEventType_1.TaskEventType.SUCCESS, () => {
            events.push(throwsError ? TaskEventType_1.TaskEventType.ERROR : TaskEventType_1.TaskEventType.SUCCESS);
        });
        task.on(TaskEventType_1.TaskEventType.END, () => {
            events.push(TaskEventType_1.TaskEventType.END);
        });
        await task.run();
        const result = events.join();
        const middleEvent = throwsError ? TaskEventType_1.TaskEventType.ERROR : TaskEventType_1.TaskEventType.SUCCESS;
        const expected = `${TaskEventType_1.TaskEventType.START},${middleEvent},${TaskEventType_1.TaskEventType.END}`;
        assert.equal(result, expected, `Events order must be: "${expected}"`);
    });
};
const createTaskArgsAndResultTestCase = (isAsync, throwsError) => {
    it(`${getTestCaseDescription(isAsync, throwsError)} return ${throwsError ? 'error' : 'result'}`, async () => {
        const value = 'echo';
        const expectedError = `Error: ${TEST_ERROR_MESSAGE}`;
        const task = new Task_1.Task(isAsync
            ? async (message) => {
                await sleep(DELAY);
                if (throwsError) {
                    throw new Error(TEST_ERROR_MESSAGE);
                }
                return message;
            }
            : (message) => {
                if (throwsError) {
                    throw new Error(TEST_ERROR_MESSAGE);
                }
                return message;
            }, value);
        const promise = new Promise(resolve => {
            task.on(TaskEventType_1.TaskEventType.END, (error, message) => {
                resolve([error, message]);
            });
        });
        await task.run();
        const [error, message] = await promise;
        if (throwsError) {
            assert.equal(error, expectedError, `Error must ends with "${TEST_ERROR_MESSAGE}"`);
        }
        else {
            assert.equal(message, value, `Result must equal ${value}`);
        }
    });
};
// Test cases
describe('"Task" class unit tests', () => {
    createEventsTestCase(false, false);
    createEventsTestCase(false, true);
    createEventsTestCase(true, false);
    createEventsTestCase(true, true);
    createTaskArgsAndResultTestCase(false, false);
    createTaskArgsAndResultTestCase(false, true);
    createTaskArgsAndResultTestCase(true, false);
    createTaskArgsAndResultTestCase(true, true);
});