oxygen-cli 1.37.8 → 1.38.0

package/build/ox_reporters/reporter-rp.js

@@ -0,0 +1,376 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("source-map-support/register");
+
+var _ReporterBase = _interopRequireDefault(require("../reporter/ReporterBase"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const RPClient = require('@oxygenhq/rp-client-javascript');
+
+const LAUNCH_MODES = {
+  DEFAULT: 'DEFAULT',
+  DEBUG: 'DEBUG'
+};
+const TEST_ITEM_TYPES = {
+  SUITE: 'SUITE',
+  TEST: 'TEST',
+  STEP: 'STEP'
+};
+const MAX_NAME_LENGTH = 128;
+
+class ReportPortalReporter extends _ReporterBase.default {
+  constructor(options, reporterOpts, aggregator) {
+    super(options);
+    this.reporterOpts = reporterOpts || options.rp;
+    this.reportSteps = reporterOpts.reportSteps || false;
+    this.reportLogs = reporterOpts.reportLogs || false;
+    this.cbSuiteToRpIdHash = {};
+    this.cbCaseToRpIdHash = {};
+    this.cbStepToRpIdHash = {};
+
+    if (!this.reporterOpts || !this.reporterOpts.apiKey || !this.reporterOpts.endpoint || !this.reporterOpts.project) {
+      throw new Error('ReportPortal options are missing in oxygen.conf file.');
+    }
+
+    this.aggregator = aggregator;
+    this.rpClient = new RPClient({
+      launch: this.reporterOpts.launch || this.options.name,
+      ...this.reporterOpts
+    });
+  }
+
+  async init() {
+    try {
+      await this.rpClient.checkConnect();
+    } catch (e) {
+      throw new Error(`RP - Error connecting to the server: ${e.message}`);
+    }
+  }
+
+  async generate(results) {}
+
+  async onRunnerStart({
+    rid,
+    opts,
+    caps
+  }) {
+    const {
+      tempId,
+      promise
+    } = this.rpClient.startLaunch({
+      mode: this.reporterOpts.mode || LAUNCH_MODES.DEFAULT,
+      debug: false
+    });
+    this.tempLaunchId = tempId;
+    promise.then(response => {}, error => {
+      console.dir(`RP - Error at the start of launch: ${error}`);
+    });
+  }
+
+  async onRunnerEnd({
+    rid,
+    result
+  }) {
+    const {
+      promise
+    } = await this.rpClient.finishLaunch(this.tempLaunchId, {
+      status: result.status.toLowerCase()
+    });
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to end launch: ${e}`);
+    }
+  }
+
+  async onSuiteStart({
+    rid,
+    suiteId,
+    suite: suiteDef
+  }) {
+    const startTestItemReq = {
+      name: suiteDef.name || this.options.name,
+      type: TEST_ITEM_TYPES.SUITE
+    };
+    const {
+      tempId,
+      promise
+    } = this.rpClient.startTestItem(startTestItemReq, this.tempLaunchId);
+    this.cbSuiteToRpIdHash[suiteId] = tempId;
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to start suite item: ${e}`);
+    }
+  }
+
+  async onSuiteEnd({
+    rid,
+    suiteId,
+    result
+  }) {
+    if (!this.cbSuiteToRpIdHash[suiteId]) {
+      return;
+    }
+
+    const rpSuiteId = this.cbSuiteToRpIdHash[suiteId];
+    const finishTestItemReq = {
+      status: result.status.toLowerCase()
+    };
+    const {
+      promise
+    } = this.rpClient.finishTestItem(rpSuiteId, finishTestItemReq);
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to finish suite item: ${e}`);
+    }
+  }
+
+  async onCaseStart({
+    rid,
+    suiteId,
+    caseId,
+    'case': caseDef
+  }) {
+    const startTestItemReq = {
+      name: caseDef.name,
+      type: TEST_ITEM_TYPES.TEST,
+      codeRef: caseDef.path
+    };
+    const rpSuiteId = this.cbSuiteToRpIdHash[suiteId];
+
+    if (!rpSuiteId) {
+      return;
+    }
+
+    const {
+      tempId,
+      promise
+    } = this.rpClient.startTestItem(startTestItemReq, this.tempLaunchId, rpSuiteId);
+    this.cbCaseToRpIdHash[caseId] = tempId;
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to start test item: ${e}`);
+    }
+  }
+
+  async onCaseEnd({
+    rid,
+    suiteId,
+    caseId,
+    result
+  }) {
+    const rpTestId = this.cbCaseToRpIdHash[caseId];
+
+    if (!rpTestId) {
+      return;
+    }
+
+    const status = result.status.toLowerCase();
+
+    if (status === 'failed' && result.failure) {
+      const rpFile = result.screenshot ? {
+        name: 'screenshot',
+        type: 'image/png',
+        content: result.screenshot
+      } : undefined;
+      const logReq = {
+        message: result.failure.message,
+        level: 'error'
+      };
+      const {
+        promise: sendLogPromise
+      } = rpFile ? this.rpClient.sendLogWithFile(rpTestId, logReq, rpFile) : this.rpClient.sendLog(rpTestId, logReq);
+      await this.promiseWithTimeout(sendLogPromise);
+    }
+
+    const finishTestItemReq = {
+      status: result.status.toLowerCase()
+    };
+    const {
+      promise
+    } = this.rpClient.finishTestItem(rpTestId, finishTestItemReq);
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to finish test item: ${e}`);
+    }
+  }
+
+  async onStepStart({
+    rid,
+    caseId,
+    step
+  }) {
+    if (!this.reportSteps) {
+      return;
+    }
+
+    const rpCaseId = this.cbCaseToRpIdHash[caseId];
+
+    if (!rpCaseId) {
+      return;
+    }
+
+    const stepName = this._getStepName(step);
+
+    const startTestItemReq = {
+      name: stepName,
+      type: TEST_ITEM_TYPES.STEP,
+      codeRef: step.location,
+      testCaseId: rpCaseId,
+      hasStats: false
+    };
+    const {
+      tempId,
+      promise
+    } = this.rpClient.startTestItem(startTestItemReq, this.tempLaunchId, rpCaseId);
+    this.cbStepToRpIdHash[step.id] = tempId;
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to start step item: ${e}`);
+    }
+  }
+
+  async onStepEnd({
+    rid,
+    step: result
+  }) {
+    if (!this.reportSteps) {
+      return;
+    }
+
+    const rpStepId = this.cbStepToRpIdHash[result.id];
+
+    if (!rpStepId) {
+      return;
+    }
+
+    const status = result.status.toLowerCase();
+
+    if (status === 'failed' && result.failure) {
+      const rpFile = result.screenshot ? {
+        name: 'screenshot',
+        type: 'image/png',
+        content: result.screenshot
+      } : undefined;
+      const logReq = {
+        message: result.failure.message,
+        level: 'error',
+        file: rpFile
+      };
+      const {
+        promise: sendLogPromise
+      } = this.rpClient.sendLog(rpStepId, logReq, rpFile);
+      await this.promiseWithTimeout(sendLogPromise);
+    }
+
+    const finishTestItemReq = {
+      status: result.status.toLowerCase()
+    };
+    const {
+      promise
+    } = this.rpClient.finishTestItem(rpStepId, finishTestItemReq);
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to finish step item: ${e}`);
+    }
+  }
+
+  async onLog({
+    suiteId,
+    caseId,
+    stepId,
+    level,
+    msg,
+    time,
+    src
+  }) {
+    if (!this.reportLogs) {
+      return;
+    }
+
+    if (!this.tempLaunchId) {
+      return;
+    }
+
+    const rpParentId = stepId ? this.cbStepToRpIdHash[stepId] : caseId ? this.cbCaseToRpIdHash[caseId] : suiteId ? this.cbSuiteToRpIdHash[suiteId] : undefined;
+
+    const rpLevel = this._getRpLevel(level);
+
+    const logReq = {
+      message: msg,
+      level: rpLevel,
+      time: time
+    };
+    const {
+      promise
+    } = this.rpClient.sendLog(rpParentId || this.tempLaunchId, logReq);
+
+    try {
+      await this.promiseWithTimeout(promise);
+    } catch (e) {
+      console.dir(`RP - Failed to create log item: ${e}`);
+    }
+  }
+
+  _getRpLevel(oxLevel) {
+    if (oxLevel) {
+      return oxLevel.toLowerCase();
+    }
+
+    return 'info';
+  }
+
+  _getStepName(step) {
+    let name;
+
+    if (step.name === 'transaction' && step.args.length > 0) {
+      name = step.args[0];
+    } else if (step.signature) {
+      name = step.signature;
+    } else if (step.module) {
+      name = `${step.module}.${step.name}`;
+    } else {
+      name = step.name;
+    }
+
+    if (name.length > MAX_NAME_LENGTH) {
+      name = name.substring(0, MAX_NAME_LENGTH - 3) + '...';
+    }
+
+    return name;
+  }
+
+  promiseWithTimeout(promise, timeout = 10 * 1000) {
+    return new Promise((resolve, reject) => {
+      if (!promise || !promise.then) {
+        reject();
+      }
+
+      promise.then(resolve, reject);
+      setTimeout(reject, timeout);
+    });
+  }
+
+}
+
+exports.default = ReportPortalReporter;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_reporters/reporter-rp.js"],"names":["RPClient","require","LAUNCH_MODES","DEFAULT","DEBUG","TEST_ITEM_TYPES","SUITE","TEST","STEP","MAX_NAME_LENGTH","ReportPortalReporter","ReporterBase","constructor","options","reporterOpts","aggregator","rp","reportSteps","reportLogs","cbSuiteToRpIdHash","cbCaseToRpIdHash","cbStepToRpIdHash","apiKey","endpoint","project","Error","rpClient","launch","name","init","checkConnect","e","message","generate","results","onRunnerStart","rid","opts","caps","tempId","promise","startLaunch","mode","debug","tempLaunchId","then","response","error","console","dir","onRunnerEnd","result","finishLaunch","status","toLowerCase","promiseWithTimeout","onSuiteStart","suiteId","suite","suiteDef","startTestItemReq","type","startTestItem","onSuiteEnd","rpSuiteId","finishTestItemReq","finishTestItem","onCaseStart","caseId","caseDef","codeRef","path","onCaseEnd","rpTestId","failure","rpFile","screenshot","content","undefined","logReq","level","sendLogPromise","sendLogWithFile","sendLog","onStepStart","step","rpCaseId","stepName","_getStepName","location","testCaseId","hasStats","id","onStepEnd","rpStepId","file","onLog","stepId","msg","time","src","rpParentId","rpLevel","_getRpLevel","oxLevel","args","length","signature","module","substring","timeout","Promise","resolve","reject","setTimeout"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/*\r\n * Oxygen Reporter for ReportPortal\r\n */\r\nimport ReporterBase from '../reporter/ReporterBase';\r\nconst RPClient = require('@oxygenhq/rp-client-javascript');\r\nconst LAUNCH_MODES = {\r\n    DEFAULT: 'DEFAULT',\r\n    DEBUG: 'DEBUG',\r\n};\r\nconst TEST_ITEM_TYPES = {\r\n    SUITE: 'SUITE',\r\n    TEST: 'TEST',\r\n    STEP: 'STEP',\r\n};\r\nconst MAX_NAME_LENGTH = 128;\r\n\r\nexport default class ReportPortalReporter extends ReporterBase {\r\n    constructor(options, reporterOpts, aggregator) {\r\n        super(options);\r\n        this.reporterOpts = reporterOpts || options.rp;\r\n        this.reportSteps = reporterOpts.reportSteps || false;\r\n        this.reportLogs = reporterOpts.reportLogs || false;\r\n        this.cbSuiteToRpIdHash = {};\r\n        this.cbCaseToRpIdHash = {};\r\n        this.cbStepToRpIdHash = {};\r\n        if (\r\n            !this.reporterOpts\r\n            || !this.reporterOpts.apiKey\r\n            || !this.reporterOpts.endpoint\r\n            || !this.reporterOpts.project\r\n        ) {\r\n            throw new Error('ReportPortal options are missing in oxygen.conf file.');\r\n        }\r\n        this.aggregator = aggregator;\r\n        this.rpClient = new RPClient({\r\n            launch: this.reporterOpts.launch || this.options.name,\r\n            ...this.reporterOpts\r\n        });\r\n    }\r\n\r\n    async init() {\r\n        try {\r\n            await this.rpClient.checkConnect();\r\n        }\r\n        catch (e) {\r\n            throw new Error(`RP - Error connecting to the server: ${e.message}`);\r\n        }\r\n    }\r\n    async generate(results) {\r\n    }\r\n    // Events\r\n    async onRunnerStart({ rid, opts, caps }) {\r\n        const { tempId, promise } = this.rpClient.startLaunch({\r\n            mode: this.reporterOpts.mode || LAUNCH_MODES.DEFAULT,\r\n            debug: false,\r\n        });\r\n        this.tempLaunchId = tempId;\r\n        promise.then((response) => {\r\n        }, (error) => {\r\n            console.dir(`RP - Error at the start of launch: ${error}`);\r\n        });\r\n    }\r\n    async onRunnerEnd({ rid, result }) {\r\n        // await this.rpClient.getPromiseFinishAllItems(this.tempLaunchId);\r\n        const { promise } = await this.rpClient.finishLaunch(this.tempLaunchId, {\r\n            status: result.status.toLowerCase(),\r\n        });\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to end launch: ${e}`);\r\n        }\r\n    }\r\n    async onSuiteStart({ rid, suiteId, suite: suiteDef }) {\r\n        const startTestItemReq = {\r\n            name: suiteDef.name || this.options.name,\r\n            type: TEST_ITEM_TYPES.SUITE,\r\n        };\r\n        const { tempId, promise } = this.rpClient.startTestItem(startTestItemReq, this.tempLaunchId);\r\n        this.cbSuiteToRpIdHash[suiteId] = tempId;\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to start suite item: ${e}`);\r\n        }\r\n    }\r\n    async onSuiteEnd({ rid, suiteId, result }) {\r\n        if (!this.cbSuiteToRpIdHash[suiteId]) {\r\n            return;\r\n        }\r\n        const rpSuiteId = this.cbSuiteToRpIdHash[suiteId];\r\n        const finishTestItemReq = {\r\n            status: result.status.toLowerCase(),\r\n        };\r\n        const { promise } = this.rpClient.finishTestItem(rpSuiteId, finishTestItemReq);\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to finish suite item: ${e}`);\r\n        }\r\n    }\r\n    async onCaseStart({ rid, suiteId, caseId, 'case': caseDef }) {\r\n        const startTestItemReq = {\r\n            name: caseDef.name,\r\n            type: TEST_ITEM_TYPES.TEST,\r\n            codeRef: caseDef.path,\r\n        };\r\n        const rpSuiteId = this.cbSuiteToRpIdHash[suiteId];\r\n        if (!rpSuiteId) {\r\n            return;\r\n        }\r\n        const { tempId, promise } = this.rpClient.startTestItem(startTestItemReq, this.tempLaunchId, rpSuiteId);\r\n        this.cbCaseToRpIdHash[caseId] = tempId;\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to start test item: ${e}`);\r\n        }\r\n    }\r\n    async onCaseEnd({ rid, suiteId, caseId, result }) {\r\n        const rpTestId = this.cbCaseToRpIdHash[caseId];\r\n        if (!rpTestId) {\r\n            return;\r\n        }\r\n        const status = result.status.toLowerCase();\r\n        if (status === 'failed' && result.failure) {\r\n            const rpFile = result.screenshot ?\r\n            {\r\n                name: 'screenshot',\r\n                type: 'image/png',\r\n                content: result.screenshot,\r\n            } : undefined;\r\n            const logReq = {\r\n                message: result.failure.message,\r\n                level: 'error'\r\n            };\r\n            const { promise: sendLogPromise } = rpFile ?\r\n                this.rpClient.sendLogWithFile(rpTestId, logReq, rpFile)\r\n                : this.rpClient.sendLog(rpTestId, logReq);\r\n\r\n            await this.promiseWithTimeout(sendLogPromise);\r\n        }\r\n        const finishTestItemReq = {\r\n            status: result.status.toLowerCase(),\r\n        };\r\n        const { promise } = this.rpClient.finishTestItem(rpTestId, finishTestItemReq);\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to finish test item: ${e}`);\r\n        }\r\n    }\r\n    async onStepStart({ rid, caseId, step }) {\r\n        if (!this.reportSteps) {\r\n            return;\r\n        }\r\n        const rpCaseId = this.cbCaseToRpIdHash[caseId];\r\n        if (!rpCaseId) {\r\n            return;\r\n        }\r\n        const stepName = this._getStepName(step);\r\n        const startTestItemReq = {\r\n            name: stepName,\r\n            type: TEST_ITEM_TYPES.STEP,\r\n            // \"codeRef\" + \"parameters\" used by RP lib to generate testCaseId if testCaseId is not defined\r\n            // see https://github.com/reportportal/client-javascript/blob/486ef70c638a9a23267290c62df1faf900f7df6a/lib/report-portal-client.js#L497\r\n            // this is disabled for now. not sure if actually needed...\r\n            //parameters: this._getRpArgs(step.args),\r\n            codeRef: step.location,\r\n            testCaseId: rpCaseId,\r\n            hasStats: false,\r\n        };\r\n        const { tempId, promise } = this.rpClient.startTestItem(startTestItemReq, this.tempLaunchId, rpCaseId);\r\n        this.cbStepToRpIdHash[step.id] = tempId;\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to start step item: ${e}`);\r\n        }\r\n    }\r\n    async onStepEnd({ rid, step: result }) {\r\n        if (!this.reportSteps) {\r\n            return;\r\n        }\r\n        const rpStepId = this.cbStepToRpIdHash[result.id];\r\n        if (!rpStepId) {\r\n            return;\r\n        }\r\n        const status = result.status.toLowerCase();\r\n        if (status === 'failed' && result.failure) {\r\n            const rpFile = result.screenshot ?\r\n            {\r\n                name: 'screenshot',\r\n                type: 'image/png',\r\n                content: result.screenshot,\r\n            } : undefined;\r\n            const logReq = {\r\n                message: result.failure.message,\r\n                level: 'error',\r\n                file: rpFile,\r\n            };\r\n            const { promise: sendLogPromise } = this.rpClient.sendLog(rpStepId, logReq, rpFile);\r\n            await this.promiseWithTimeout(sendLogPromise);\r\n        }\r\n        const finishTestItemReq = {\r\n            status: result.status.toLowerCase(),\r\n        };\r\n        const { promise } = this.rpClient.finishTestItem(rpStepId, finishTestItemReq);\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to finish step item: ${e}`);\r\n        }\r\n    }\r\n    async onLog({ suiteId, caseId, stepId, level, msg, time, src }) {\r\n        if (!this.reportLogs) {\r\n            return;\r\n        }\r\n        // Oxygen might start generating logs before onRunnerStart event, ignore them\r\n        if (!this.tempLaunchId) {\r\n            return;\r\n        }\r\n        const rpParentId = stepId ?\r\n            this.cbStepToRpIdHash[stepId]\r\n            : caseId ? this.cbCaseToRpIdHash[caseId]\r\n            : suiteId ? this.cbSuiteToRpIdHash[suiteId]\r\n            : undefined;\r\n        const rpLevel = this._getRpLevel(level);\r\n        const logReq = {\r\n            message: msg,\r\n            level: rpLevel,\r\n            time: time,\r\n        };\r\n        const { promise } = this.rpClient.sendLog(rpParentId || this.tempLaunchId, logReq);\r\n        try {\r\n            await this.promiseWithTimeout(promise);\r\n        }\r\n        catch (e) {\r\n            console.dir(`RP - Failed to create log item: ${e}`);\r\n        }\r\n    }\r\n    _getRpLevel(oxLevel) {\r\n        if (oxLevel) {\r\n            return oxLevel.toLowerCase();\r\n        }\r\n        return 'info';\r\n    }\r\n    /*_getRpArgs(cbArgs) {\r\n        if (!cbArgs || !cbArgs.length) {\r\n            return undefined;\r\n        }\r\n        const rpArgs = [];\r\n        for (let i=0; i < cbArgs.length; i++) {\r\n            const arg = cbArgs[i];\r\n            let argStr = typeof arg === 'string' || arg instanceof String ? arg : JSON.stringify(arg);\r\n            rpArgs.push({\r\n                key: `arg${i}`,\r\n                value: argStr\r\n            });\r\n        }\r\n        return rpArgs;\r\n    }*/\r\n    _getStepName(step) {\r\n        let name;\r\n\r\n        if (step.name === 'transaction' && step.args.length > 0) {  // FIXME: steps need to be nested under transactions\r\n            name = step.args[0];\r\n        }\r\n        else if (step.signature) {\r\n            name = step.signature;\r\n        }\r\n        else if (step.module) {                         // FIXME: is this ever reached? \"step.signature\" seems to always exist\r\n            name = `${step.module}.${step.name}`;\r\n        }\r\n        else {\r\n            name = step.name;\r\n        }\r\n\r\n        // maximum allowed name length in RP is 1024 bytes\r\n        // we truncate it even lower so it will display nicely\r\n        if (name.length > MAX_NAME_LENGTH) {\r\n            name = name.substring(0, MAX_NAME_LENGTH-3) + '...';\r\n        }\r\n        return name;\r\n    }\r\n    promiseWithTimeout(promise, timeout = 10 * 1000) {\r\n        return new Promise((resolve, reject) => {\r\n            if (!promise || !promise.then) {\r\n                reject();\r\n            }\r\n            promise.then(resolve, reject);\r\n            setTimeout(reject, timeout);\r\n        });\r\n    }\r\n}\r\n\r\n"]}