runner-runtime 1.0.8

package/events/index.js

@@ -0,0 +1,272 @@
+const atomicSleep = require("atomic-sleep"),
+    jsonpath = require("jsonpath"),
+    JSON5 = require('json5'),
+    _ = require('lodash'),
+    { returnBoolean, variableReplace } = require('../libs/utils');
+const executeApi = require('./api'),
+    executeWait = require('./wait');
+
+const events = {
+    api: executeApi,
+    sample: executeApi,
+    sse: executeApi,
+    request: executeApi, // 特殊一些。1、相当于复制；2、无目录 todo....
+    script: executeApi,
+    assert: executeApi,
+    assert_visual: executeApi,
+    sql: executeApi,
+    wait: executeWait, //  ok
+    if: async (event, option, callback, eventRuntimeData, eventResultList) => {  //  ok
+        try {
+            const { data, children } = event;
+            const exp = variableReplace(data?.var, eventRuntimeData?.variables, option),
+                compare = data?.compare, value = variableReplace(data?.value, eventRuntimeData?.variables, option);
+
+            if (returnBoolean(exp, compare, value)) {
+                if (_.isArray(children) && !_.isEmpty(children)) {
+                    const { iterationData } = option;
+                    await iterationEvent(children, _.assign(_.cloneDeep(option), { iterationData: [iterationData] }), callback, eventRuntimeData, eventResultList)
+                }
+
+                return ({
+                    action: 'ifConditionSuccess',
+                    condition: { var: exp, compare, value },
+                    current_event_id: event?.event_id
+                });
+            } else {
+                return ({
+                    action: 'ifConditionFailed',
+                    condition: { var: exp, compare, value },
+                    current_event_id: event?.event_id
+                })
+            }
+        } catch (e) {
+            return ({
+                action: 'stystemError',
+                message: String(e),
+                current_event_id: event?.event_id
+            })
+        }
+    },
+    begin: async (event, option, callback, eventRuntimeData, eventResultList) => {  //  ok
+        try {
+            const { data, children } = event;
+
+            if (_.isArray(children) && !_.isEmpty(children)) {
+                const { iterationData, enable_data } = data;
+
+                if (_.toInteger(enable_data) > 0) {
+                    await iterationEvent(children, _.assign(_.cloneDeep(option), { iterationData }), callback, eventRuntimeData, eventResultList)
+                } else {
+                    await iterationEvent(children, option, callback, eventRuntimeData, eventResultList)
+                }
+            }
+
+            return ({
+                action: 'beginComplete',
+                current_event_id: event?.event_id
+            });
+        } catch (e) {
+            return ({
+                action: 'stystemError',
+                message: String(e),
+                current_event_id: event?.event_id
+            })
+        }
+    },
+    loop: async (event, option, callback, eventRuntimeData, eventResultList) => { // ok
+        try {
+            const { data, children } = event;
+            const sleep = _.toInteger(variableReplace(_.get(data, 'sleep', 0), eventRuntimeData?.variables, option));
+            const startTime = _.toInteger(_.get(option, 'startTime', Date.now()));
+            const timeout = _.toInteger(_.get(option, 'timeout', _.toInteger(variableReplace(_.get(data, 'loop_timeout', 0), eventRuntimeData?.variables, option))));
+
+            if (_.isArray(children) && !_.isEmpty(children)) {
+                const iterationData = [];
+                const enableData = _.toInteger(data?.enable_data) || 1;
+
+                if (enableData > 0) {
+                    const loopDataType = _.toInteger(data?.loop_data_type) || 1;
+                    switch (loopDataType) {
+                        case 1:
+                            _.assign(iterationData, _.values(_.get(data, 'loop_traverse_data.iterationData', [])))
+                            break;
+                        case 2:
+                            const previousEventId = _.trim(_.get(data, 'loop_iteration_data'));
+
+                            if (_.isString(previousEventId) && previousEventId != '') {
+                                const dataTypeMap = {
+                                    1: `response.body`,
+                                    2: `response.headers`,
+                                    3: `response.cookies`,
+                                    4: `response.code`,
+                                    5: `request.url`,
+                                    6: `request.method`,
+                                    7: `request.querys`,
+                                    8: `request.body`,
+                                    9: `request.headers`,
+                                    10: `request.cookies`,
+                                };
+                                const dataSourceType = _.toInteger(_.get(data, 'loop_extract.var'));
+                                const responseData = _.get(eventRuntimeData, `${previousEventId}.${dataTypeMap[dataSourceType] || "response.body"}`);
+                                const dataJsonPath = _.trim(String(_.get(data, 'loop_extract.value', '$')));
+
+                                switch (dataSourceType) {
+                                    case 1:
+                                    case 8:
+                                        try {
+                                            _.assign(iterationData, _.values(jsonpath.value(responseData, dataJsonPath)));
+                                        } catch (e) { }
+                                        break;
+                                    case 2:
+                                    case 3:
+                                    case 7:
+                                    case 9:
+                                    case 10:
+                                        _.assign(iterationData, _.values(_.get(responseData, dataJsonPath)));
+                                        break;
+                                    case 4:
+                                    case 5:
+                                    case 6:
+                                        _.assign(iterationData, _.values(responseData));
+                                        break;
+                                }
+                            }
+
+                            break;
+                        case 3:
+                            let loopVariable = variableReplace(_.get(data, 'loop_variable', ''), eventRuntimeData?.variables, option);
+
+                            if (!_.isObject(loopVariable)) {
+                                loopVariable = _.values(loopVariable);
+                            } else {
+                                try {
+                                    loopVariable = JSON5.parse(loopVariable);
+                                } catch (e) {
+                                    loopVariable = [];
+                                }
+                            }
+                            _.assign(iterationData, loopVariable);
+                            break;
+                        case 4:
+                            _.assign(iterationData, _.split(_.get(data, 'loop_fixed_value', ''), ','))
+                            break;
+                    }
+                }
+
+                // 获取循环次数
+                const loopType = _.toInteger(_.get(data, 'loop_type', 1));
+
+                if (_.includes([1, 2], loopType)) {
+                    const limit = loopType === 1 ? _.size(iterationData) : _.toInteger(_.get(data, 'limit', 1));
+
+                    if (limit > 0) {
+                        const events = _.flatten(_.times(limit, () => _.cloneDeep(children)));
+                        await iterationEvent(events, _.assign(_.cloneDeep(option), { iterationData, sleep, startTime, timeout }), callback, eventRuntimeData, eventResultList)
+                    }
+                } else if (_.includes([3], loopType)) {
+                    const condition = _.get(option, 'condition', _.get(data, 'loop_condition', {}));
+                    const exp = variableReplace(condition?.var, eventRuntimeData?.variables, option), compare = condition?.compare, value = variableReplace(condition?.value, eventRuntimeData?.variables, option);
+
+                    while (true) {
+                        if (startTime + timeout > Date.now() && !returnBoolean(exp, compare, value)) {
+                            await iterationEvent(_.cloneDeep(children), _.assign(_.cloneDeep(option), { iterationData, sleep, condition, startTime, timeout }), callback, eventRuntimeData, eventResultList);
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return ({
+                action: 'loopComplete',
+                current_event_id: event?.event_id
+            });
+        } catch (e) {
+            return ({
+                action: 'stystemError',
+                message: String(e),
+                current_event_id: event?.event_id
+            })
+        }
+    }
+};
+
+// 调度器核心函数，用于递归执行具体场景步骤
+const executeEvent = (event, option, callback, eventRuntimeData, eventResultList) => {
+    return new Promise((resolve, reject) => {
+        if (_.isUndefined(_.get(eventRuntimeData, event.event_id))) {
+            _.set(eventRuntimeData, event.event_id, {});
+        }
+        const eventCall = _.get(events, `${event?.type}`);
+
+        if (_.isFunction(eventCall)) {
+            try {
+                eventCall(event, option, callback, eventRuntimeData, eventResultList).then((data) => {
+                    resolve(data);
+
+                    const { total, scene } = option;
+                    if (scene == 'auto_test' && _.isInteger(event?.progress)) {
+                        callback({
+                            action: 'inProcess',
+                            progress: event?.progress + 1,
+                            total,
+                            current_event_id: event?.event_id
+                        })
+                    }
+                })
+            } catch (e) { // 中止跳出执行的系统错误
+                if (_.toInteger(option?.ignore_error) < 1) {
+                    reject({
+                        action: 'stystemError',
+                        message: String(e),
+                        current_event_id: event?.event_id
+                    })
+                }
+            }
+        } else {
+            reject({
+                action: 'warningError',
+                message: `This function \`${event?.type}\` is not currently supported.`,
+                current_event_id: event?.event_id
+            })
+        }
+    })
+}
+
+const iterationEvent = async (events, option, callback, eventRuntimeData, eventResultList) => {
+    const event = events.shift();
+
+    if (_.isObject(event) && _.has(event, 'type') && _.toInteger(event?.enabled) > 0) {
+        let { iterationDataArr } = option;
+
+        if (!_.isArray(iterationDataArr)) {
+            iterationDataArr = _.values(iterationDataArr);
+        }
+
+        const iterationData = iterationDataArr.shift() || {};
+        try {
+            const { sleep } = option;
+            const data = await executeEvent(event, { ...option, iterationData }, callback, eventRuntimeData, eventResultList);
+            callback(data);
+
+            if (_.toInteger(sleep) > 0) {
+                atomicSleep(sleep);
+            }
+        } catch (e) {
+            callback(e);
+
+            if (_.includes(ABORT_RECURSION_ERROR, e?.action)) {
+                throw new Error(String(e?.message));
+            }
+        }
+
+        if (_.isArray(events) && !_.isEmpty(events)) {
+            await iterationEvent(events, { ...option, iterationDataArr }, callback, eventRuntimeData, eventResultList);
+        }
+    }
+}
+
+module.exports = {
+    executeEvent, iterationEvent
+};

package/events/wait.js

@@ -0,0 +1,27 @@
+const atomicSleep = require("atomic-sleep"),
+    _ = require('lodash');
+const { variableReplace } = require("../libs/utils");
+
+module.exports = (event, option, callback, eventRuntimeData,eventResultList) => {
+    return new Promise((resolve) => {
+        try {
+            const sleep = _.toInteger(variableReplace(event?.data?.sleep, eventRuntimeData?.variables, option)) || 0;
+
+            if (sleep > 0) {
+                atomicSleep(sleep)
+            }
+
+            resolve({
+                action: 'sleep',
+                sleep,
+                current_event_id: event?.event_id
+            })
+        } catch (e) {
+            resolve({
+                action: 'stystemError',
+                message: String(e),
+                current_event_id: event?.event_id
+            })
+        }
+    });
+}

package/index.js

@@ -0,0 +1,75 @@
+const { repeatArrayToLength, formatAutotestReport } = require('./libs/utils');
+const _ = require('lodash');
+const { executeEvent, iterationEvent } = require('./events');
+const ABORT_RECURSION_ERROR = ['stystemError']; //需要跳出递归的错误
+
+// 执行场景
+const run = async (events, option, callback) => {
+    const { iterationCount, iterationData, scene } = option;
+    const tempEvents = _.cloneDeep(_.flatten(new Array(scene == 'auto_test' ? _.max([_.toInteger(iterationCount), 1]) : 1).fill(events))) || [];
+    const iterationDataArr = repeatArrayToLength(iterationData, _.size(tempEvents));
+    const eventOptions = _.pick(option, ["scene", "lang", "project", "env", "globals", "cookies", "system_configs", "custom_functions", "collection", "database_configs", "enable_sandbox", "sleep", "name", "testing_id"]);
+    const eventRuntimeData = {
+        variables: {}
+    };
+    const eventResultList = [];
+    const startTimeAt = Date.now();
+
+    // 单接口测试
+    if (scene == 'http_request') {
+        const event = _.first(tempEvents);
+
+        if (_.isObject(event) && _.has(event, 'type')) {
+            try {
+                const data = await executeEvent(event, _.assign(eventOptions, { iterationData: {} }), callback, eventRuntimeData, eventResultList);
+                callback(data)
+            } catch (e) {
+                callback(e);
+
+                if (_.includes(ABORT_RECURSION_ERROR, e?.action)) {
+                    throw new Error(String(e?.message));
+                }
+            }
+        }
+    } else if (scene == 'get_parsed_request') {
+        const event = _.first(tempEvents);
+
+        if (_.isObject(event) && _.has(event, 'type')) {
+            try {
+                const data = await executeEvent(event, _.assign(eventOptions, { iterationData: {} }), callback, eventRuntimeData, eventResultList);
+                callback(data)
+            } catch (e) {
+                callback(e);
+
+                if (_.includes(ABORT_RECURSION_ERROR, e?.action)) {
+                    throw new Error(String(e?.message));
+                }
+            }
+        }
+    } else {
+        const finalEvents = [];
+        _.forEach(tempEvents, (event, progress) => {
+            if (event?.enabled > 0) {
+                finalEvents.push(_.assign(_.cloneDeep(event), { progress }))
+            }
+        })
+
+        // 自动化测试
+        if (!_.isEmpty(finalEvents)) {
+            const total = _.size(finalEvents);
+            await iterationEvent(finalEvents, _.assign(eventOptions, { iterationDataArr, total }), callback, eventRuntimeData, eventResultList);
+        } else {
+            callback({
+                action: 'emptyEvents'
+            })
+        }
+
+        callback({
+            action: 'complete',
+            data: _.assign(formatAutotestReport(startTimeAt, eventResultList), {
+                list: eventResultList
+            })
+        })
+    }
+}
+module.exports = { run }