@testomatio/reporter 1.3.6-beta → 1.4.1-beta-1

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) {
@@ -33,12 +33,19 @@ class TestomatioPipe {
     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;
@@ -46,62 +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: {
@@ -109,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;
@@ -145,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,
@@ -153,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() {
@@ -170,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-functions.js

@@ -0,0 +1,43 @@
+const logger = require('./storages/logger');
+const artifactStorage = require('./storages/artifact-storage');
+const keyValueStorage = require('./storages/key-value-storage');
+
+/**
+ * Stores path to file as artifact and uploads it to the S3 storage
+ * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
+ */
+function saveArtifact(data, context = null) {
+  if (!data) return;
+  artifactStorage.put(data, context);
+}
+
+/**
+ * Attach log message(s) to the test report
+ * @param  {...any} args
+ */
+function logMessage(...args) {
+  logger.log(...args);
+}
+
+/**
+ * Similar to "log" function but marks message in report as a step
+ * @param {*} message 
+ */
+function addStep(message) {
+  logger.step(message);
+}
+
+/**
+ * Add key-value pair(s) to the test report
+ * @param {*} keyValue 
+ */
+function setKeyValue(keyValue) {
+  keyValueStorage.put(keyValue);
+}
+
+module.exports = {
+  artifact: saveArtifact,
+  log: logMessage,
+  step: addStep,
+  keyValue: setKeyValue,
+};

package/lib/reporter.js

@@ -1,17 +1,23 @@
-const logger = require('./logger');
+const logger = require('./storages/logger');
 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);
+const reporterFunctions = require('./reporter-functions');
 
 module.exports = {
   logger,
+  testomatioLogger: logger,
   log,
   step,
   TestomatClient,
   TRConstants,
-  TRArtifacts,
-  addArtifact: TRArtifacts.artifact,
+};
+
+module.exports.testomat = {
+  artifact: reporterFunctions.artifact,
+  log: reporterFunctions.log,
+  step: reporterFunctions.step,
+  meta: reporterFunctions.keyValue,
 };

package/lib/storages/artifact-storage.js

@@ -0,0 +1,70 @@
+const debug = require('debug')('@testomatio/reporter:artifact-storage');
+const DataStorage = require('./data-storage');
+
+/**
+ * Artifact storage is supposed to store file paths
+ */
+class ArtifactStorage {
+
+  // there is autocompletion for the class methods if implemented singleton this way
+  constructor() {
+    this.dataStorage = new DataStorage('artifact');
+    
+    // singleton
+    if (!ArtifactStorage.instance) {
+      ArtifactStorage.instance = this;
+    }
+  }
+
+  // singleton
+  static getInstance() {
+    if (!ArtifactStorage.instance) {
+      ArtifactStorage.instance = new ArtifactStorage();
+    }
+
+    return ArtifactStorage.instance;
+  }
+
+  /**
+   * Stores path to file as artifact and uploads it to the S3 storage
+   * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
+   * @param {*} context testId or test title
+   */
+  put(data, context = null) {
+    if (!data) return;
+    debug('Save artifact:', data);
+    this.dataStorage.putData(data, context);
+  }
+
+  /**
+   * Returns list of artifacts to upload
+   * @param {*} context testId or test context from test runner
+   * @returns {string | {path: string, type: string, name: string}[]}
+   */
+  get(context) {
+    if (!context) return null;
+
+    // array of any data
+    let artifacts = this.dataStorage.getData(context);
+    if (!artifacts || !artifacts.length) return null;
+
+    artifacts = artifacts.map(artifactData => {
+      // artifact could be an object ({type, path, name} props) or string
+      let artifact;
+      try {
+        artifact = JSON.parse(artifactData);
+      } catch (e) {
+        artifact = artifactData;
+      }
+      return artifact;
+    });
+    artifacts = artifacts.filter(artifact => !!artifact);
+    return artifacts.length ? artifacts : null;
+  }
+}
+
+ArtifactStorage.instance = null;
+
+// const artifactStorage = ArtifactStorage.getInstance();
+const artifactStorage = new ArtifactStorage();
+module.exports = artifactStorage;