@mmisty/cypress-allure-adapter/plugins/server.js

cypress allure adapter to generate allure results during tests execution (Allure TestOps compatible)

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.startReporterServer = exports.testMessages = void 0;
const ws_1 = require("ws");
const net_1 = __importDefault(require("net"));
const common_1 = require("../common");
const debug_1 = __importDefault(require("debug"));
const debug = (0, debug_1.default)('cypress-allure:server');
const logMessage = (0, debug_1.default)('cypress-allure:server:message');
const log = (...args) => {
    debug(`${args}`);
};
// for testing
exports.testMessages = [];
const messageGot = (...args) => {
    logMessage(`${args}`);
};
const checkPortSync = (port, timeoutMs = 2000) => {
    let isAvailable = true;
    let server = null;
    let timeoutReached = false;
    const startTime = Date.now();
    try {
        server = net_1.default.createServer();
        server.listen(port);
        server.on('error', (err) => {
            if (err.code === 'EADDRINUSE') {
                isAvailable = false;
            }
        });
        const checkTimeout = () => {
            if (Date.now() - startTime >= timeoutMs) {
                timeoutReached = true;
            }
        };
        const waitForListening = () => {
            if (!(server === null || server === void 0 ? void 0 : server.listening) && !timeoutReached) {
                process.nextTick(waitForListening); // Yield to event loop
                checkTimeout(); // Check if timeout has been reached
            }
        };
        waitForListening();
        if (timeoutReached) {
            throw new Error(`Timeout waiting for port ${port} to become available.`);
        }
    }
    catch (error) {
        isAvailable = false;
    }
    finally {
        if (server) {
            server.close();
        }
    }
    return isAvailable;
};
function retrieveRandomPortNumber() {
    const getRandomPort = () => 40000 + Math.round(Math.random() * 25000);
    let port = getRandomPort();
    for (let i = 0; i < 30; i++) {
        const result = checkPortSync(port);
        if (result) {
            return port;
        }
        port = getRandomPort();
    }
    (0, common_1.logWithPackage)('error', 'could not find free port, will not report');
    return port;
}
const socketLogic = (sockserver, tasks) => {
    if (!sockserver) {
        log('Could not start reporting server');
        return;
    }
    sockserver.on('connection', ws => {
        log('New client connected!');
        ws.send('connection established');
        ws.on('close', () => {
            log('Client has disconnected!');
        });
        ws.on('message', data => {
            messageGot('message received');
            messageGot(data);
            exports.testMessages.push(`${data}`);
            const parseData = (data) => {
                try {
                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                    return JSON.parse(data.toString());
                }
                catch (e) {
                    // console.log((e as Error).message);
                    return {};
                }
            };
            const requestData = parseData(data);
            const payload = requestData.data;
            if (requestData.id) {
                const result = executeTask(tasks, payload);
                sockserver.clients.forEach(client => {
                    log(`sending back: ${JSON.stringify(requestData)}`);
                    client.send(JSON.stringify({ payload, status: result ? 'done' : 'failed' }));
                });
            }
            else {
                sockserver.clients.forEach(client => {
                    log(`sending back: ${JSON.stringify(requestData)}`);
                    client.send(JSON.stringify({ payload, status: 'done' }));
                });
            }
        });
        ws.onerror = function () {
            (0, common_1.logWithPackage)('error', 'websocket error');
        };
    });
};
const startReporterServer = (configOptions, tasks, attempt = 0) => {
    const wsPort = retrieveRandomPortNumber();
    let sockserver = new ws_1.WebSocketServer({ port: wsPort, path: common_1.wsPath }, () => {
        configOptions.env[common_1.ENV_WS] = wsPort;
        const attemptMessage = attempt > 0 ? ` from ${attempt} attempt` : '';
        (0, common_1.logWithPackage)('log', `running on ${wsPort} port${attemptMessage}`);
        socketLogic(sockserver, tasks);
    });
    sockserver.on('error', err => {
        if (err.message.indexOf('address already in use') !== -1) {
            if (attempt < 30) {
                process.nextTick(() => {
                    sockserver = (0, exports.startReporterServer)(configOptions, tasks, attempt + 1);
                });
            }
            else {
                (0, common_1.logWithPackage)('error', `Could not find free port, will not report: ${err.message}`);
            }
            return;
        }
        (0, common_1.logWithPackage)('error', `Error on ws server: ${err.message}`);
    });
    return sockserver;
};
exports.startReporterServer = startReporterServer;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const executeTask = (tasks, data) => {
    if (!data || !data.task) {
        log(`Will not run task - not data or task field:${JSON.stringify(data)}`);
        return false;
    }
    try {
        if (Object.keys(tasks).indexOf(data.task) !== -1) {
            const task = data.task; // todo check
            log(task);
            tasks[task](data.arg);
            return true;
        }
        else {
            log(`No such task: ${data.task}`);
        }
    }
    catch (err) {
        (0, common_1.logWithPackage)('error', `Error running task: '${data.task}': ${err.message}`);
        // eslint-disable-next-line no-console
        console.log(err.stack);
    }
    return false;
};