@testomatio/reporter 1.2.0-beta → 1.2.0-beta-2

package/lib/pipe/html.js

@@ -0,0 +1,262 @@
+const debug = require('debug')('@testomatio/reporter:pipe:html');
+const merge = require('lodash.merge');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const handlebars = require('handlebars');
+
+const { fileSystem, isSameTest, ansiRegExp } = require('../utils/utils');
+const { HTML_REPORT } = require('../constants');
+
+class HtmlPipe {
+    constructor(params, store = {}) {
+        this.store = store || {};
+        this.title = params.title || process.env.TESTOMATIO_TITLE;
+        this.apiKey = params.apiKey || process.env.TESTOMATIO;
+        this.isHtml = process.env.TESTOMATIO_HTML_REPORT_SAVE;
+        this.data = {};
+
+        debug('HTML Pipe: ', this.apiKey ? 'API KEY' : '*no api key*');
+        if (!this.apiKey) {
+            return;
+        }
+
+        this.isEnabled = false;
+        this.htmlOutputPath = "";
+        this.tests = [];
+        this.data = {};
+
+        if (this.isHtml) {
+            this.isEnabled = true;
+            this.htmlReportDir = process.env.TESTOMATIO_HTML_REPORT_FOLDER || HTML_REPORT.FOLDER;
+
+            if (process.env.TESTOMATIO_HTML_FILENAME && process.env.TESTOMATIO_HTML_FILENAME.endsWith(".html")) {
+                this.htmlReportName = process.env.TESTOMATIO_HTML_FILENAME
+            }
+
+            if (process.env.TESTOMATIO_HTML_FILENAME && !process.env.TESTOMATIO_HTML_FILENAME.endsWith(".html")) {
+                console.log(
+                    chalk.blue(`The name must include the extension ".html". The default report name is used!`)
+                );
+                this.htmlReportName = HTML_REPORT.REPORT_DEFAULT_NAME;
+            }
+
+            if (!process.env.TESTOMATIO_HTML_FILENAME) {
+                this.htmlReportName = HTML_REPORT.REPORT_DEFAULT_NAME;
+            }
+
+            this.templateFolderPath = path.resolve(__dirname, '..', 'template');
+            this.templateHtmlPath = path.resolve(this.templateFolderPath, HTML_REPORT.TEMPLATE_NAME);
+            this.htmlOutputPath = path.join(this.htmlReportDir, this.htmlReportName);
+            // create a new folder for the HTML reports
+            fileSystem.createDir(this.htmlReportDir);
+
+            debug(
+                chalk.yellow('HTML Pipe:'),
+                `Save HTML report: ${this.isEnabled}`,
+                `HTML report folder: ${this.htmlReportDir}, report name: ${this.htmlReportName}`
+            );
+        }
+    }
+
+    async createRun() {
+        // empty
+    }
+
+    updateRun() {
+        // empty
+    }
+
+    /**
+     * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+     * @param {Object} test - object which includes each test entry.
+     */
+    addTest(test) {
+        if (!this.isEnabled) return;
+
+        if (!test.steps || !test.status) return;
+
+        const index = this.tests.findIndex(t => isSameTest(t, test));
+        // update if they were already added
+        if (index >= 0) {
+            this.tests[index] = merge(this.tests[index], test);
+            return;
+        }
+
+        this.tests.push(test);
+    }
+
+    async finishRun(runParams) {
+        if (!this.isEnabled) return;
+
+        if (this.isHtml) {
+
+            this.tests.forEach(test => {
+
+                if (!test.message || test.message.trim() === "") {
+                    test.message = "This test has no 'message' code";
+                }
+    
+                if (!test.suite_title || test.suite_title.trim() === "") {
+                    test.suite_title = "Unknown suite";
+                }
+
+                if (!test.title || test.title.trim() === "") {
+                    test.title = "Unknown test title";
+                }
+
+                if (!test.files || test.files.length === 0) {
+                    test.files = "This test has no files";
+                }
+
+                if (test.steps) {
+                    if (!test.steps || test.steps.trim() === "") {
+                        test.steps = "This test has no 'steps' code";
+                    }
+                    else {
+                        test.steps = this.#removeAnsiColorCodes(test.steps);
+                    }
+                }
+                
+                // TODO: u can added an additional test values to this checks in the future
+            });
+
+            this.data = {
+                runId: this.store.runId,
+                status: runParams.status,
+                parallel: runParams.isParallel,
+                runUrl: this.store.runUrl,
+                executionTime: testExecutionSumTime(this.tests),
+                executionDate: getCurrentDateTimeFormatted(),
+                tests: this.tests 
+            };
+
+            // GENERATE HTML reports based on the results data
+            this.buildReport(this.data);
+        }
+    }
+
+    buildReport(data) {
+        debug('HTML tests data:', data);
+
+        if (!this.htmlOutputPath && this.htmlOutputPath !== "") {
+            console.log(chalk.yellow(`HTML export path is not set, ignoring...`));
+            return;
+        }
+
+        console.log(chalk.yellow(`The test results will be added to the HTML report. It will take some time...`));
+        // generate output HTML based on the template
+        const html = this.#generateHTMLReport(data);
+
+        fs.writeFileSync(this.htmlOutputPath, html, 'utf-8');
+    }
+
+    #generateHTMLReport(data) {
+        if (!this.templateHtmlPath) {
+            console.log(chalk.red(`HTML template not found. Report generation is impossible!`))
+            return;
+        }
+
+        const templateSource = fs.readFileSync(this.templateHtmlPath, 'utf8');
+        this.#loadReportHelpers();
+        try {
+            const template = handlebars.compile(templateSource);
+
+            console.log(chalk.green(`Generated HTML report saved in file: ${this.htmlOutputPath}`));
+            return template(data);
+        }
+        catch (e) {
+            console.log('Unknown HTML report generation error: ', e);
+        }
+    }
+
+    #loadReportHelpers() {
+        handlebars.registerHelper('getTestsByStatus', (tests, status) => 
+            tests.filter(test => test.status.toLowerCase() === status.toLowerCase()).length
+        );
+
+        handlebars.registerHelper('json', (tests) => {
+            function replaceScriptTagsInArray(array) {
+                return array.map(obj => {
+                    const keysToCheck = ["steps", "stack", "title", "suite_title", "message", "code"];
+                    const newObj = {};
+            
+                    for (const key in obj) {
+                        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                            if (key === "example") {
+                                newObj[key] = {};
+                                for (const subKey in obj[key]) {
+                                    if (Object.prototype.hasOwnProperty.call(obj[key], subKey)) {
+                                        newObj[key][subKey] = typeof obj[key][subKey] === "string"
+                                            ? obj[key][subKey]
+                                                .replace(/<script>/g, "<$cript>")
+                                                .replace(/<\/script>/g, "</$cript>")
+                                            : obj[key][subKey];
+                                    }
+                                }
+                            } else if (keysToCheck.includes(key)) {
+                                newObj[key] = typeof obj[key] === "string"
+                                    ? obj[key].replace(/<script>/g, "<$cript>").replace(/<\/script>/g, "</$cript>")
+                                    : obj[key];
+                            } else {
+                                newObj[key] = obj[key];
+                            }
+                        }
+                    }
+            
+                    return newObj;
+                });
+            }
+
+            // Remove ANSI escape codes
+            return JSON.stringify(replaceScriptTagsInArray(tests));
+        });
+    }
+
+    #removeAnsiColorCodes(str) {
+        let updatedStr = str.replace(ansiRegExp(), "");        
+        updatedStr = updatedStr.replace(/\n/g, '<br>');
+
+        return updatedStr;
+    }
+
+    toString() {
+        return 'HTML Reporter';
+    }
+}
+
+function testExecutionSumTime(tests) {
+    const totalMilliseconds = tests.reduce((sum, test) => {
+        if (typeof test.run_time === 'number') {
+            return sum + test.run_time;
+        }
+        return sum;
+    }, 0);
+
+    return formatDuration(totalMilliseconds);
+}
+
+function formatDuration(duration) {
+    const milliseconds = duration % 1000;
+    duration = (duration - milliseconds) / 1000;
+    const seconds = duration % 60;
+    duration = (duration - seconds) / 60;
+    const minutes = duration % 60;
+    const hours = (duration - minutes) / 60;
+
+    return `${hours}h ${minutes}m ${seconds}s ${milliseconds}ms`;
+}
+
+function getCurrentDateTimeFormatted() {
+    const currentDate = new Date();
+    const day = currentDate.getDate().toString().padStart(2, '0');
+    const month = (currentDate.getMonth() + 1).toString().padStart(2, '0');
+    const year = currentDate.getFullYear();
+    const hours = currentDate.getHours().toString().padStart(2, '0');
+    const minutes = currentDate.getMinutes().toString().padStart(2, '0');
+    const seconds = currentDate.getSeconds().toString().padStart(2, '0');
+
+    return `(${day}/${month}/${year} ${hours}:${minutes}:${seconds})`;
+}
+
+module.exports = HtmlPipe;

package/lib/pipe/index.js

@@ -6,6 +6,7 @@ const TestomatioPipe = require('./testomatio');
 const GitHubPipe = require('./github');
 const GitLabPipe = require('./gitlab');
 const CsvPipe = require('./csv');
+const HtmlPipe = require('./html');
 
 function PipeFactory(params, opts) {
   const extraPipes = [];
@@ -43,6 +44,7 @@ function PipeFactory(params, opts) {
     new GitHubPipe(params, opts),
     new GitLabPipe(params, opts),
     new CsvPipe(params, opts),
+    new HtmlPipe(params, opts),
     ...extraPipes,
   ];
 

package/lib/pipe/testomatio.js

@@ -3,8 +3,8 @@ const chalk = require('chalk');
 const axios = require('axios');
 const JsonCycle = require('json-cycle');
 const { APP_PREFIX, STATUS } = require('../constants');
-const { isValidUrl } = require('../util');
-const { resetConfig } = require('../fileUploader');
+const { isValidUrl, foundedTestLog } = require('../utils/utils');
+const { parseFilterParams, generateFilterRequestParams, setS3Credentials, } = require('../utils/pipe_utils');
 
 const { TESTOMATIO_RUN } = process.env;
 if (TESTOMATIO_RUN) {
@@ -27,17 +27,25 @@ class TestomatioPipe {
       return;
     }
     debug('Testomatio Pipe: Enabled');
+    this.parallel = params.parallel;
     this.store = store || {};
     this.title = params.title || process.env.TESTOMATIO_TITLE;
     this.sharedRun = !!process.env.TESTOMATIO_SHARED_RUN;
     this.groupTitle = params.groupTitle || process.env.TESTOMATIO_RUNGROUP_TITLE;
     this.env = process.env.TESTOMATIO_ENV;
-    this.axios = axios.create();
+
+    this.axios = axios.create({
+      baseURL: `${this.url.trim()}`,
+      timeout: 30000
+    });
+
     this.isEnabled = true;
     // do not finish this run (for parallel testing)
     this.proceed = process.env.TESTOMATIO_PROCEED;
+    this.jiraId = process.env.TESTOMATIO_JIRA_ID;
     this.runId = params.runId || process.env.runId;
-    this.createNewTests = !!process.env.TESTOMATIO_CREATE;
+    this.createNewTests = params.createNewTests ?? !!process.env.TESTOMATIO_CREATE;
+    this.hasUnmatchedTests = false;
 
     if (!isValidUrl(this.url.trim())) {
       this.isEnabled = false;
@@ -45,61 +53,135 @@ class TestomatioPipe {
     }
   }
 
+  /**
+   * Asynchronously prepares and retrieves the Testomat.io test grepList based on the provided options.
+   * @param {Object} opts - The options for preparing the test grepList.
+   * @returns {Promise<string[]>} - An array containing the retrieved 
+   * test grepList, or an empty array if no tests are found or the request is disabled.
+   * @throws {Error} - Throws an error if there was a problem while making the request.
+   */
+  async prepareRun(opts) {
+    if (!this.isEnabled) return [];
+
+    const { type, id } = parseFilterParams(opts);
+
+    try {
+      const q = generateFilterRequestParams({
+        type,
+        id,
+        apiKey: this.apiKey.trim()
+      });
+
+      if (!q) {
+        return;
+      }
+
+      const resp = await this.axios.get('/api/test_grep', q);
+      const { data } = resp;
+
+      if (Array.isArray(data?.tests) && data?.tests?.length > 0) {
+        foundedTestLog(APP_PREFIX, data.tests);
+        return data.tests;
+      }
+      
+      console.log(APP_PREFIX, `⛔  No tests found for your --filter --> ${type}=${id}`);
+    }
+    catch (err) {
+      console.error(
+        APP_PREFIX,
+        `🚩 Error getting Testomat.io test grepList: ${err}`,
+      );
+    }
+  }
+
   /**
    * @returns Promise<void>
    */
   async createRun() {
+    debug('Creating run...');
     if (!this.isEnabled) return;
 
+    let buildUrl = process.env.BUILD_URL || process.env.CI_JOB_URL || process.env.CIRCLE_BUILD_URL;
+
+    // GitHub Actions Url
+    if (!buildUrl && process.env.GITHUB_RUN_ID) {
+      // eslint-disable-next-line max-len
+      buildUrl = `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+    }
+
+    // Azure DevOps Url
+    if (!buildUrl && process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI) {
+      const collectionUri = process.env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI;
+      const project = process.env.SYSTEM_TEAMPROJECT;
+      const buildId = process.env.BUILD_BUILDID;
+      buildUrl = `${collectionUri}/${project}/_build/results?buildId=${buildId}`;
+    }
+
+    if (buildUrl && !buildUrl.startsWith('http')) buildUrl = undefined;
+
+    const accessEvent = process.env.TESTOMATIO_PUBLISH ? 'publish' : null;
+
     const runParams = Object.fromEntries(
       Object.entries({
+        ci_build_url: buildUrl,
+        parallel: this.parallel,
         api_key: this.apiKey.trim(),
         group_title: this.groupTitle,
+        access_event: accessEvent,
+        jira_id: this.jiraId,
         env: this.env,
         title: this.title,
         shared_run: this.sharedRun,
-      }).filter(([, value]) => !!value)
+      }).filter(([, value]) => !!value),
     );
+    debug('Run params', JSON.stringify(runParams, null, 2));
 
     if (this.runId) {
-      const resp = await this.axios.put(`${this.url.trim()}/api/reporter/${this.runId}`, runParams);
+      debug(`Run with id ${this.runId} already created, updating...`);
+      const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
     }
 
     try {
-      const resp = await this.axios.post(`${this.url.trim()}/api/reporter`, runParams, {
+      const resp = await this.axios.post(`/api/reporter`, runParams, {
         maxContentLength: Infinity,
         maxBodyLength: Infinity,
       });
       this.runId = resp.data.uid;
       this.runUrl = `${this.url}/${resp.data.url.split('/').splice(3).join('/')}`;
+      this.runPublicUrl = resp.data.public_url;
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       this.store.runUrl = this.runUrl;
+      this.store.runPublicUrl = this.runPublicUrl;
       this.store.runId = this.runId;
       console.log(APP_PREFIX, '📊 Report created. Report ID:', this.runId);
       process.env.runId = this.runId;
+      debug('Run created', this.runId);
     } catch (err) {
       console.error(
         APP_PREFIX,
         'Error creating Testomat.io report, please check if your API key is valid. Skipping report',
+        err,
       );
     }
+    debug('"createRun" function finished');
   }
 
   /**
-   * 
-   * @param testData data 
-   * @returns 
+   *
+   * @param testData data
+   * @returns
    */
   addTest(data) {
+    debug('Adding test...');
     if (!this.isEnabled) return;
     if (!this.runId) return;
     data.api_key = this.apiKey;
     data.create = this.createNewTests;
     const json = JsonCycle.stringify(data);
 
-    return this.axios.post(`${this.url}/api/reporter/${this.runId}/testrun`, json, {
+    return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, {
       maxContentLength: Infinity,
       maxBodyLength: Infinity,
       headers: {
@@ -107,29 +189,37 @@ class TestomatioPipe {
         'Content-Type': 'application/json',
       },
     })
-    .catch((err) => {
+    .catch(err => {
       if (err.response) {
         if (err.response.status >= 400) {
           const responseData = err.response.data || { message: '' };
           console.log(
             APP_PREFIX,
-            chalk.blue(this.title),
-            `Report couldn't be processed: (${err.response.status}) ${responseData.message}`,
+            chalk.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+            chalk.grey(data?.title || ''),
           );
+          if (err.response.data.message.includes('could not be matched')) {
+            this.hasUnmatchedTests = true;
+          }
           return;
         }
-        console.log(APP_PREFIX, chalk.blue(this.title), `Report couldn't be processed: ${err.response.data.message}`);
+        console.log(
+          APP_PREFIX,
+          chalk.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
+          `Report couldn't be processed: ${err?.response?.data?.message}`,
+        );
       } else {
-        console.log(APP_PREFIX, chalk.blue(this.title), "Report couldn't be processed", err);
+        console.log(APP_PREFIX, chalk.blue(data?.title || ''), "Report couldn't be processed", err);
       }
     });
   }
 
   /**
-   * @param {import('../../types').RunData} params 
-   * @returns 
+   * @param {import('../../types').RunData} params
+   * @returns
    */
   async finishRun(params) {
+    debug('Finishing run...');
     if (!this.isEnabled) return;
 
     const { status, parallel } = params;
@@ -143,7 +233,7 @@ class TestomatioPipe {
 
     try {
       if (this.runId && !this.proceed) {
-        await this.axios.put(`${this.url}/api/reporter/${this.runId}`, {
+        await this.axios.put(`/api/reporter/${this.runId}`, {
           api_key: this.apiKey,
           status_event,
           tests: params.tests,
@@ -151,15 +241,44 @@ class TestomatioPipe {
         if (this.runUrl) {
           console.log(APP_PREFIX, '📊 Report Saved. Report URL:', chalk.magenta(this.runUrl));
         }
+        if (this.runPublicUrl) {
+          console.log(APP_PREFIX, '🌟 Public URL:', chalk.magenta(this.runPublicUrl));
+        }
       }
       if (this.runUrl && this.proceed) {
         const notFinishedMessage = chalk.yellow.bold('Run was not finished because of $TESTOMATIO_PROCEED');
         console.log(APP_PREFIX, `📊 ${notFinishedMessage}. Report URL: ${chalk.magenta(this.runUrl)}`);
         console.log(APP_PREFIX, `🛬 Run to finish it: TESTOMATIO_RUN=${this.runId} npx start-test-run --finish`);
       }
+      if (this.hasUnmatchedTests) {
+        console.log('');
+        // eslint-disable-next-line max-len
+        console.log(APP_PREFIX, chalk.yellow.bold('⚠️ Some reported tests were not found in Testomat.io project'));
+        // eslint-disable-next-line max-len
+        console.log(
+          APP_PREFIX,
+          `If you use Testomat.io as a reporter only, please re-run tests using ${chalk.bold('TESTOMATIO_CREATE=1')}`,
+        );
+        // eslint-disable-next-line max-len
+        console.log(
+          APP_PREFIX,
+          `But to keep your tests consistent it is recommended to ${chalk.bold('import tests first')}`,
+        );
+        console.log(APP_PREFIX, 'If tests were imported but still not matched, assign test IDs to your tests.');
+        console.log(APP_PREFIX, 'You can do that automatically via command line tools:');
+        console.log(APP_PREFIX, chalk.bold('npx check-tests ... --update-ids'), 'See: https://bit.ly/js-update-ids');
+        console.log(APP_PREFIX, 'or for Cucumber:');
+        // eslint-disable-next-line max-len
+        console.log(
+          APP_PREFIX,
+          chalk.bold('npx check-cucumber ... --update-ids'),
+          'See: https://bit.ly/bdd-update-ids',
+        );
+      }
     } catch (err) {
       console.log(APP_PREFIX, 'Error updating status, skipping...', err);
     }
+    debug('Run finished');
   }
 
   toString() {
@@ -168,18 +287,3 @@ class TestomatioPipe {
 }
 
 module.exports = TestomatioPipe;
-
-
-function setS3Credentials(artifacts) {  
-  if (!Object.keys(artifacts).length) return;
-
-  console.log(APP_PREFIX, 'S3 were credentials obtained from Testomat.io...');
-
-  if (artifacts.ACCESS_KEY_ID) process.env.S3_ACCESS_KEY_ID = artifacts.ACCESS_KEY_ID; 
-  if (artifacts.SECRET_ACCESS_KEY) process.env.S3_SECRET_ACCESS_KEY = artifacts.SECRET_ACCESS_KEY; 
-  if (artifacts.REGION) process.env.S3_REGION = artifacts.REGION; 
-  if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET; 
-  if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT; 
-  if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1'; 
-  resetConfig();
-}

package/lib/reporter.js

@@ -3,11 +3,12 @@ const TestomatClient = require('./client');
 const TRConstants = require('./constants');
 const TRArtifacts = require('./_ArtifactStorageOld');
 
-const log = logger._log.bind(logger);
+const log = logger.templateLiteralLog.bind(logger);
 const step = logger.step.bind(logger);
 
 module.exports = {
   logger,
+  testomatioLogger: logger,
   log,
   step,
   TestomatClient,

package/lib/template/real-data-example.js

@@ -0,0 +1,47 @@
+// TODO: use as example for the unit-tests
+
+const result = {
+    "runId": "51eb2798",
+    "status": "failed",
+    "runUrl": "https://beta.testomat.io/projects/codecept-new-mode-exmple/runs/51eb2798/report",
+    "executionTime": "0 seconds",
+    "executionDate": "(30/07/2023 11:11:11)",
+    "tests": [{
+        "files": [],
+        "steps": "\u001b[32m\u001b[1mOn TodosPage: goto \u001b[22m\u001b[39m\n",
+        "status": "passed",
+        "stack": "I execute script () => sessionStorage.clear()",
+        "example": null,
+        "code": null,
+        "title": "Create a new todo item @T50e82737",
+        "suite_title": "Create Tasks @step:06 @smoke @story:12 @S2f5c1942",
+        "test_id": "50e82737",
+        "message": "",
+        "run_time": 121,
+        "artifacts": [],
+        "api_key": "tstmt_gRqrhBUaVxTpezGpZjRmlahOeqcRBBbDMA1692050199",
+        "create": false
+    }, {
+        "files": [{
+            "path": "/home/codeceptjs-testomat-example/codeceptJS/output/Create_2_@T5b8d1186.failed.png",
+            "type": "image/png"
+        }],
+        "steps": "I am on page \"http://todomvc.com/examples/angularjs/#/\"",
+        "status": "failed",
+        "stack": "I am on page \"http://todomvc.com/examples/angularjs/#/\"",
+        "example": null,
+        "code": null,
+        "title": "Create a new todo item part 2 @T5b8d1186",
+        "suite_title": "@second Create Tasks @step:07 @smoke @story:13 @S2f5c1942",
+        "test_id": "5b8d1186",
+        "message": "expected expected number of visible is 2, but found 1 \"1\" to equal \"2\"",
+        "run_time": 176,
+        "artifacts": [null],
+        "api_key": "tstmt_gRqrhBUaVxTpezGpZjRmlahOeqcRBBbDMA1692050199",
+        "create": false
+    }]
+}
+
+module.exports = {
+    result
+}