runner-runtime 1.0.90 → 1.0.91

package/libs/utils.js

@@ -1,604 +0,0 @@
-const atomicSleep = require("atomic-sleep"),
-    _ = require('lodash'),
-    fs = require("fs"),
-    jsf = require("json-schema-faker-pro"),
-    path = require("path"),
-    { mockExp } = require('exp-mock'),
-    Mock = require('mockjs5-pro'),
-    mime = require("mime"),
-    os = require("os"),
-    Buffer = require("buffer/").Buffer,
-    urlJoin = require("@apipost/url-join");
-
-// 获取某接口的详细信息
-const getAPIFromCollection = function (collection, target_id) {
-    return _.find(collection, _.matchesProperty("target_id", target_id));
-};
-
-// 获取某接口的 所有父target
-const getParentTargetIDs = function (collection, target_id, parent_ids) {
-    if (_.isArray(collection)) {
-
-        const item = _.find(collection, _.matchesProperty("target_id", target_id));
-
-        if (item) {
-            if (parent_ids.includes(item.parent_id)) {
-                return;
-            }
-
-            if (_.isString(item.parent_id)) {
-                parent_ids.push(item.parent_id);
-                getParentTargetIDs(collection, item.parent_id, parent_ids);
-            }
-        }
-    }
-};
-
-// url 拼接
-const smartUrlJoin = (base, ...paths) => {
-    // 检查paths中是否有完整的URL
-    for (let path of paths) {
-        if (/^[a-zA-Z]+:\/\//.test(path)) {
-            return path;
-        }
-    }
-
-    // 如果没有完整的URL，则使用url-join正常合并
-    return urlJoin(base, ...paths);
-}
-
-//replace2RegExp
-const replace2RegExp = (str, replace, value) => {
-    try {
-        return _.replace(str, new RegExp(String(replace), 'ig'), String(value))
-    } catch (e) {
-        return _.replace(str, replace, String(value))
-    }
-}
-
-const base64toCacheFile = (key, value, base64, dirpath) => {
-    let src = value;
-    try {
-        fs.statSync(src);
-    } catch (e) {
-        if (!_.isEmpty(base64)) {
-            const match = String(base64).match(/data:([0-9a-zA-Z\/\-]+);base64,/i);
-            const ext = mime.getExtension(match && match[1] ? match[1] : "");
-
-            if (_.isString(ext)) {
-                const tempDirPath = path.resolve(os.tmpdir(), `${dirpath}`);
-                try {
-                    fs.mkdirSync(tempDirPath);
-                } catch (e) { }
-
-                let tempFileName = value;
-                if (!_.endsWith(tempFileName, `.${ext}`)) {
-                    tempFileName = `${key}.${ext}`;
-                }
-
-                const tempFilePath = path.resolve(tempDirPath, tempFileName);
-                try {
-                    fs.writeFileSync(
-                        tempFilePath,
-                        Buffer.from(_.replace(base64, /^data:[0-9a-zA-Z\/\-]+;base64,/, ""), "base64")
-                    );
-                    src = tempFilePath;
-                } catch (e) { }
-            }
-        }
-    }
-
-    return src;
-}
-
-// generateNorthAmericanPhoneNumber
-const generateNorthAmericanPhoneNumber = () => {
-    const areaCode = Math.floor(Math.random() * 900) + 100; // 100-999
-    const phoneNumber = Math.floor(Math.random() * 10000000) + 1000000; // 1000000-9999999
-    const formattedPhoneNumber = `${areaCode}-${phoneNumber.toString().slice(0, 3)}-${phoneNumber.toString().slice(3)}`;
-
-    return formattedPhoneNumber;
-}
-
-// generateChinesePhoneNumber
-const generateChinesePhoneNumber = () => {
-    let phoneNumber = '1';
-    phoneNumber += _.random(3, 9).toString();
-    phoneNumber += _.times(9, () => _.random(0, 9)).join('');
-    return phoneNumber;
-}
-
-const getInsideVariables = () => {
-    const list = {};
-
-    new Array(
-        "natural",
-        "integer",
-        "float",
-        "character",
-        "range",
-        "date",
-        "time",
-        "datetime",
-        "now",
-        "guid",
-        "increment",
-        "url",
-        "protocol",
-        "domain",
-        "tld",
-        "email",
-        "ip",
-        "region",
-        "province",
-        "city",
-        "county",
-        "county",
-        "zip",
-        "first",
-        "last",
-        "name",
-        "cfirst",
-        "clast",
-        "cname",
-        "color",
-        "rgb",
-        "rgba",
-        "hsl",
-        "paragraph",
-        "cparagraph",
-        "sentence",
-        "csentence",
-        "word",
-        "cword",
-        "title",
-        "ctitle",
-        "username",
-        "user_name",
-        "nickname",
-        "nick_name",
-        "avatar",
-        "icon",
-        "img",
-        "photo",
-        "pic",
-        "description",
-        "id",
-        "userid",
-        "user_id",
-        "articleid",
-        "article_id"
-    ).forEach((func) => {
-        list[`$${func}`] = Mock.mock(`@${func}`);
-    });
-
-    if (process && process?.IS_ECHOAPI) {
-        //echoapi
-        const blackArray = ['region', 'province', 'city', 'county', 'cfirst', 'clast', 'cname', 'cparagraph', 'csentence', 'cword', 'ctitle']
-        function createReturnFunction(param) {
-            return function () {
-                return param;
-            };
-        }
-        blackArray.forEach((func) => {
-            list[`$${func}`] = createReturnFunction(`$${func}`);
-        });
-
-        new Array("phone", "mobile", "telephone").forEach((func) => {
-            list[`$${func}`] = generateNorthAmericanPhoneNumber();
-        });
-    } else {
-        new Array("phone", "mobile", "telephone").forEach((func) => {
-            list[`$${func}`] = generateChinesePhoneNumber();
-        });
-    }
-
-    // 兼容 v3
-    list.$timestamp = (function () {
-        return _.toInteger(Date.now() / 1000);
-    })();
-
-    list.$microTimestamp = (function () {
-        return new Date().getTime();
-    })();
-
-    list.$randomInt = (function () {
-        return Math.floor(Math.random() * 1000);
-    })();
-
-    list.$randomFloat = (function () {
-        return Math.random() * 1000;
-    })();
-
-    return list;
-}
-
-const repeatArrayToLength = (arr, targetLength) => {
-    if (!_.isArray(arr)) {
-        arr = _.values(arr);
-    }
-
-    if (_.isEmpty(arr)) {
-        return [];
-    }
-
-    const repeatTimes = _.ceil(targetLength / arr.length);
-    const repeatedArray = _.flattenDeep(_.fill(new Array(repeatTimes), arr));
-    return _.take(repeatedArray, targetLength);
-}
-
-const returnBoolean = (exp, compare, value) => {
-    let bool = false;
-    if (exp === "") {
-        // fix bug
-        return compare == "null";
-    }
-
-    switch (compare) {
-        case "eq":
-            bool = exp == value;
-            break;
-        case "uneq":
-            bool = exp != value;
-            break;
-        case "gt":
-            bool = _.gt(Number(exp), Number(value));
-            break;
-        case "gte":
-            bool = _.gte(Number(exp), Number(value));
-            break;
-        case "lt":
-            bool = _.lt(Number(exp), Number(value));
-            break;
-        case "lte":
-            bool = _.lte(Number(exp), Number(value));
-            break;
-        case "includes":
-            bool = _.includes(exp, value) || _.includes(exp, Number(value));
-            break;
-        case "unincludes":
-            bool = !_.includes(exp, value) && !_.includes(exp, Number(value));
-            break;
-        case "null":
-            bool = _.isEmpty(exp);
-            break;
-        case "notnull":
-            bool = !_.isEmpty(exp);
-            break;
-        case "exist":
-            bool = !_.isUndefined(exp);
-            break;
-        case "notexist":
-            bool = _.isUndefined(exp);
-            break;
-        case "regularmatch":
-            try {
-                bool = new RegExp(
-                    String(value).substring(1, String(value).length - 1)
-                ).test(exp);
-            } catch (e) { }
-            break;
-        case "belongscollection":
-            bool = _.split(value, ",").indexOf(exp) > -1;
-            break;
-        case "notbelongscollection":
-            bool = _.split(value, ",").indexOf(exp) == -1;
-            break;
-    }
-
-    return bool;
-};
-
-const getCaseInsensitive = (object, keyToFind) => {
-    try {
-        // 先将要查找的键转换成小写
-        const lowerKey = _.toLower(keyToFind);
-
-        if (!_.isObject(object)) {
-            return undefined;
-        }
-
-        // 在对象的所有键中查找
-        for (const key in object) {
-            if (_.toLower(key) === lowerKey) {
-                return object[key];
-            }
-        }
-    } catch (e) { }
-
-    // 如果没有找到，返回undefined
-    return undefined;
-}
-
-const variableReplace = (str, variables, option) => {
-    const AllVars = getInsideVariables();
-    ["globals", "_globals", "environment", "iterationData", "variables"].forEach((varName) => {
-        _.assign(AllVars, _.get(variables, `${varName}`))
-    })
-
-    str = _.replace(str, /\{\{([^}]+)\}\}/g, (match, key) => {
-        return _.get(AllVars, key.trim(), match);
-    });
-
-    const { lang, custom_functions } = option;
-
-    try {
-        return mockExp(str, AllVars, lang, custom_functions)
-    } catch (e) {
-        return str;
-    }
-}
-
-const variableReplaceForCondition = (str, variables, option) => {
-    if (!_.startsWith(str, '{{') || !_.endsWith(str, '}}')) {
-        return str;
-    }
-
-    const AllVars = getInsideVariables();
-    ["globals", "_globals", "environment", "iterationData", "variables"].forEach((varName) => {
-        _.assign(AllVars, _.get(variables, `${varName}`))
-    })
-
-    str = _.replace(str, /\{\{([^}]+)\}\}/g, (match, key) => {
-        return _.get(AllVars, key.trim(), match);
-    });
-
-    const { lang, custom_functions } = option;
-
-    try {
-        const finalStr = mockExp(str, AllVars, lang, custom_functions);
-
-        if (finalStr === str && _.startsWith(str, '{{') && _.endsWith(str, '}}')) {
-            return undefined
-        }
-        return finalStr;
-    } catch (e) {
-        return undefined;
-    }
-}
-
-const formatAutotestReportList = (eventResultList) => {
-    const list = [];
-    _.forEach(_.cloneDeep(eventResultList), (item) => {
-        const type = item?.type;
-
-        if (_.includes(['assert', 'assert_visual', 'api', 'sample', 'script', 'sql'], type)) {
-            list.push(_.assign(
-                _.pick(item?.response, ['timings', 'response_time', 'response_at', 'proxy', 'status', 'code', 'response_size']),
-                _.pick(item?.request, ['url', 'method', 'name', 'target_id', 'project_id']),
-                _.pick(item, ['type', 'event_id', 'test_id', 'iteration_id', 'startTime', 'endTime', 'currentVariables']),
-                {
-                    type,
-                    'status': {
-                        "assert": _.isEmpty(item?.status?.success_assert) ? "OK" : item?.status?.success_assert,
-                        "http": item?.status?.http || "OK"
-                    }
-                },
-            ))
-        } else if (_.includes(['if'], type)) {
-            list.push(_.assign(
-                _.pick(item, ['type', 'event_id', 'test_id', 'iteration_id', 'startTime', 'endTime', 'currentVariables']),
-                {
-                    type,
-                    'status': {
-                        ...item?.data
-                    }
-                },
-            ))
-        } else if (_.includes(['wait'], type)) {
-            list.push(_.assign(
-                _.pick(item, ['type', 'event_id', 'test_id', 'iteration_id', 'startTime', 'endTime', 'currentVariables']),
-                {
-                    type,
-                    'sleep': item?.data?.sleep || 0
-                },
-            ))
-        }
-
-    })
-
-    return list;
-}
-
-const formatAutotestReport = (startTimeAt, eventResultList) => {
-    const report = {
-        "assert": {
-            "total": 0,
-            "success": 0,
-            "error": 0
-        },
-        "http": {
-            "total": 0,
-            "success": 0,
-            "error": 0
-        },
-        "start_at": startTimeAt,
-        "end_at": Date.now(),
-        "total_time": Date.now() - startTimeAt,
-        "iteration_count": _.size(eventResultList),
-        "total_response_time": null,
-        "avg_response_time": null,
-        "total_response_size": 0,
-        "avg_response_size": 0
-    };
-
-    let totalResponseSize = 0, totalResponseTime = 0
-
-    _.forEach(_.cloneDeep(eventResultList), (item) => {
-        if (_.includes(['api', 'sample'], item?.type)) {
-            report.http.total++;
-            totalResponseSize = totalResponseSize + _.toInteger(item?.response?.response_size);
-            totalResponseTime = totalResponseTime + _.toInteger(item?.response?.response_time);
-
-            if (_.toLower(item?.status?.http) != 'ok') {
-                report.http.error++;
-            }
-        }
-
-        if (_.includes(['api', 'sample', 'assert', 'assert_visual'], item?.type) && !_.isEmpty(item?.status?.assert) && _.isArray(item?.status?.assert)) {
-            const assertFailure = _.filter(item?.status?.assert, (assertItem) => {
-                return assertItem?.passed === false
-            })
-
-            report.assert.total = report.assert.total + _.size(item?.status?.assert);
-            report.assert.error = report.assert.error + _.size(assertFailure);
-        }
-    })
-
-    report.http.success = report.http.total - report.http.error;
-    report.assert.success = report.assert.total - report.assert.error;
-    report.avg_response_time = _.round(totalResponseTime / report.http.total, 2) || 0;
-    report.avg_response_size = _.round(totalResponseSize / report.http.total, 2) || 0;
-    report.total_response_time = totalResponseTime;
-    report.total_response_size = totalResponseSize;
-
-    return report;
-}
-
-
-const camelCaseToSnakeCase = (obj) => {
-    ["arrCookies", "fitForShow", "mimeType", "requestStart", "responseSize", "responseTime",].forEach((key) => {
-        const _key = _.snakeCase(key);
-        const objValue = _.get(obj, `response.${key}`);
-        if (!_.isUndefined(objValue)) {
-            _.set(obj, `response.${_key}`, objValue);
-            _.unset(obj, `response.${key}`);
-        }
-    });
-
-    return obj;
-}
-
-const encodeURIComponentUnique = (str) => {
-    if (_.startsWith(str, '{{') && _.endsWith(str, '}}')) {
-        return str;
-    } else {
-        try {
-            if (decodeURIComponent(str) == str) {
-                return encodeURIComponent(str);
-            }
-            return str;
-        } catch (e) {
-            return encodeURIComponent(str);
-        }
-    }
-}
-
-const jsfGenerate = (schema, mockRules = [], lang, customFunctions = {}) => {
-    jsf.option({
-        alwaysFakeOptionals: true,
-        useExamplesValue: true,
-        fillProperties: false,
-        useDefaultValue: true,
-        mockRules,
-        customFunctions,
-        lang: 'zh-cn',
-    });
-
-    let genResult = undefined;
-
-    if (_.some(["default", "examples", "pattern", "format", "x-mock", "enum"], (value) => _.includes(_.keys(schema?.schema || schema), value))) {
-        try {
-            genResult = jsf.generate(schema);
-        } catch (e) { }
-    }
-
-    if (!_.isUndefined(genResult)) {
-        return genResult;
-    }
-}
-
-const getVariableActedUpon = (eventRuntimeData, varName) => {
-    let actedUpon = undefined;
-    ["variables", "iterationData", "environment", "globals"].some((type) => {
-        if (_.includes(_.keys(_.get(eventRuntimeData, `variables.${type}`)), varName)) {
-            actedUpon = type;
-            return true;
-        }
-    })
-
-    return actedUpon;
-}
-
-const convertEndRuntimeState = (eventRuntimeData, event_id) => {
-    try {
-        const { startTime, startVariables } = _.get(eventRuntimeData, [event_id, 'iteration'], {});
-        const endTime = Date.now();
-        const startAllVars = {};
-        const startAllActedUponVars = {};
-
-        ["globals", "environment", "iterationData", "variables"].forEach((type) => {
-            _.assign(startAllVars, _.get(startVariables, `${type}`))
-        })
-
-        _.forEach(startAllVars, (value, key) => {
-            _.set(startAllActedUponVars, [key, 'value'], value);
-
-            let startActedUpon = undefined;
-
-            if (!_.isUndefined(value)) {
-                ["variables", "iterationData", "environment", "globals"].some((type) => {
-                    if (!_.isUndefined(_.get(startVariables, [`${type}`, key]))) {
-                        startActedUpon = type;
-                        return true;
-                    }
-                })
-            }
-            _.set(startAllActedUponVars, [key, 'actedUpon'], startActedUpon);
-        })
-
-        // 当前变量
-        const { environment = {}, variables = {}, _globals = {}, iterationData = {} } = _.get(eventRuntimeData, 'variables', {});
-        const endVariables = { environment, variables, iterationData, globals: _globals };
-        const endAllVars = {};
-        ["globals", "environment", "iterationData", "variables"].forEach((type) => {
-            _.assign(endAllVars, _.get(endVariables, `${type}`))
-        })
-
-        // 变量追踪
-        const currentVariables = {};
-
-        _.forEach(endAllVars, (value, key) => {
-            if (!_.includes(['_pm.response.code', '_pm.response.setBody'], key)) {
-                let actedUpon = undefined;
-                ["variables", "iterationData", "environment", "globals"].some((type) => {
-                    if (!_.isUndefined(_.get(endVariables, [`${type}`, key]))) {
-                        actedUpon = type;
-                        return true;
-                    }
-                })
-
-                _.set(currentVariables, [key], {
-                    start: _.pick(startAllActedUponVars[key], ['value', 'actedUpon']),
-                    current: { value, actedUpon }
-                })
-            }
-        })
-
-        return { startTime, endTime, currentVariables };
-    } catch (e) { }
-}
-
-
-module.exports = {
-    atomicSleep,
-    jsfGenerate,
-    getAPIFromCollection,
-    getParentTargetIDs,
-    base64toCacheFile,
-    replace2RegExp,
-    getInsideVariables,
-    repeatArrayToLength,
-    convertEndRuntimeState,
-    returnBoolean,
-    variableReplaceForCondition,
-    getCaseInsensitive,
-    camelCaseToSnakeCase,
-    formatAutotestReportList,
-    getVariableActedUpon,
-    variableReplace,
-    // createPipeServer,
-    formatAutotestReport,
-    encodeURIComponentUnique,
-    smartUrlJoin
-}