@testomatio/reporter 2.6.0-beta.1.allure → 2.6.1

package/src/pipe/testomatio.js

@@ -3,11 +3,12 @@ import pc from 'picocolors';
 import { Gaxios } from 'gaxios';
 import JsonCycle from 'json-cycle';
 import { APP_PREFIX, STATUS, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
-import { isValidUrl, 
-  foundedTestLog, 
-  readLatestRunId, 
-  transformEnvVarToBoolean, 
-  getGitCommitSha 
+import {
+  isValidUrl,
+  foundedTestLog,
+  readLatestRunId,
+  transformEnvVarToBoolean,
+  getGitCommitSha,
 } from '../utils/utils.js';
 import { parseFilterParams, generateFilterRequestParams, setS3Credentials } from '../utils/pipe_utils.js';
 import { config } from '../config.js';
@@ -25,7 +26,7 @@ if (process.env.TESTOMATIO_RUN) process.env.runId = process.env.TESTOMATIO_RUN;
 class TestomatioPipe {
   constructor(params, store) {
     this.batch = {
-      isEnabled: params?.isBatchEnabled ?? !transformEnvVarToBoolean(process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD),
+      isEnabled: params?.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
       intervalFunction: null, // will be created in createRun by setInterval function
       intervalTime: 5000, // how often tests are sent
       tests: [], // array of tests in batch
@@ -198,6 +199,9 @@ class TestomatioPipe {
     if (!this.isEnabled) return;
     if (this.batch.isEnabled && this.isEnabled)
       this.batch.intervalFunction = setInterval(this.#batchUpload, this.batch.intervalTime);
+    if (this.store) {
+      this.store.runKind = params.kind;
+    }
 
     let buildUrl = process.env.BUILD_URL || process.env.CI_JOB_URL || process.env.CIRCLE_BUILD_URL;
 
@@ -219,6 +223,16 @@ class TestomatioPipe {
 
     const accessEvent = process.env.TESTOMATIO_PUBLISH ? 'publish' : null;
 
+    const coverageConfiguration = this.store?.coverageConfiguration;
+    let description = null;
+    let configuration = null;
+    if (coverageConfiguration && (coverageConfiguration.tests?.length || coverageConfiguration.suites?.length)) {
+      description = this.store?.coverageDescription || null;
+      configuration = {
+        tests: coverageConfiguration.tests?.map(id => id.replace(/^T/, '')) || [],
+        suites: coverageConfiguration.suites?.map(id => id.replace(/^S/, '')) || [],
+      };
+    }
     const runParams = Object.fromEntries(
       Object.entries({
         ci_build_url: buildUrl,
@@ -232,6 +246,8 @@ class TestomatioPipe {
         shared_run: this.sharedRun,
         shared_run_timeout: this.sharedRunTimeout,
         kind: params.kind,
+        configuration,
+        description,
       }).filter(([, value]) => !!value),
     );
     debug(' >>>>>> Run params', JSON.stringify(runParams, null, 2));
@@ -246,6 +262,15 @@ class TestomatioPipe {
         responseType: 'json',
       });
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
+      if (resp.data.url) {
+        const respUrl = new URL(resp.data.url);
+        this.runUrl = `${this.url}${respUrl.pathname}`;
+        this.runPublicUrl = resp.data.public_url;
+        this.store.runUrl = this.runUrl;
+        this.store.runPublicUrl = this.runPublicUrl;
+        console.log(APP_PREFIX, '📊 Using existing run. Report ID:', this.runId);
+        console.log(APP_PREFIX, '📊 Report URL:', pc.magenta(this.runUrl));
+      }
       return;
     }
 
@@ -278,11 +303,13 @@ class TestomatioPipe {
       if (!this.apiKey) console.error('Testomat.io API key is not set');
       if (!this.apiKey?.startsWith('tstmt')) console.error('Testomat.io API key is invalid');
 
+      if (process.env.DEBUG || process.env.TESTOMATIO_DEBUG) this.#logFailedResponse(err);
+
       console.error(
         APP_PREFIX,
         'Error creating Testomat.io report (see details above), please check if your API key is valid. Skipping report',
       );
-      printCreateIssue(err);
+      printCreateIssue();
     }
     debug('"createRun" function finished');
   }
@@ -329,24 +356,8 @@ class TestomatioPipe {
         this.requestFailures++;
         this.notReportedTestsCount++;
         if (err.response) {
-          if (err.response.status >= 400) {
-            const responseData = err.response.data || { message: '' };
-            console.log(
-              APP_PREFIX,
-              pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
-              pc.gray(data?.title || ''),
-            );
-            if (err.response?.data?.message?.includes('could not be matched')) {
-              this.hasUnmatchedTests = true;
-            }
-            return;
-          }
-          console.log(
-            APP_PREFIX,
-            pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
-            `Report couldn't be processed: ${err?.response?.data?.message}`,
-          );
-          printCreateIssue(err);
+          this.#logFailedResponse(err);
+          printCreateIssue();
         } else {
           console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
         }
@@ -395,20 +406,8 @@ class TestomatioPipe {
         this.requestFailures++;
         this.notReportedTestsCount += testsToSend.length;
         if (err.response) {
-          if (err.response.status >= 400) {
-            const responseData = err.response.data || { message: '' };
-            console.log(APP_PREFIX, pc.yellow(`Warning: ${responseData.message} (${err.response.status})`));
-            if (err.response?.data?.message?.includes('could not be matched')) {
-              this.hasUnmatchedTests = true;
-            }
-            return;
-          }
-          console.log(
-            APP_PREFIX,
-            pc.yellow(`Warning: (${err.response?.status})`),
-            `Report couldn't be processed: ${err?.response?.data?.message}`,
-          );
-          printCreateIssue(err);
+          this.#logFailedResponse(err);
+          printCreateIssue();
         } else {
           console.log(APP_PREFIX, "Report couldn't be processed", err);
         }
@@ -521,37 +520,83 @@ class TestomatioPipe {
       }
     } catch (err) {
       console.log(APP_PREFIX, 'Error updating status, skipping...', err);
-      printCreateIssue(err);
+      if (process.env.DEBUG || process.env.TESTOMATIO_DEBUG) this.#logFailedResponse(err);
+      printCreateIssue();
     }
     debug('Run finished');
   }
 
+  #logFailedResponse(error) {
+    let responseBody = stringify(error.response?.data ?? error.response ?? error, { pretty: true });
+    if (!responseBody) responseBody = '<empty>';
+    responseBody = hideTestomatioToken(responseBody);
+
+    const statusCode = error.status || error.code || error.response?.status || '<unknown status code>';
+    const method = error.response?.config.method || '<unknown method>';
+    const url = error.response?.config.url || '<unknown url>';
+
+    let message = pc.yellow('\n⚠️ Request to Testomat.io failed:\n');
+    message += pc.bold(`${pc.red(statusCode)} ${method} ${url}\n`);
+    message += `\t${pc.bold('response: ')}${pc.gray(responseBody)}\n`;
+
+    const requestBody = hideTestomatioToken(stringify(error.response?.config?.data));
+    if (process.env.DEBUG || process.env.TESTOMATIO_DEBUG) {
+      message += `\t${pc.bold('request: ')}${pc.gray(requestBody)}\n`;
+    } else {
+      const requestBodyCut = requestBody.slice(0, 1000);
+      message += `\t${pc.bold('request: ')}${pc.gray(`${requestBodyCut}.....`)}\n`;
+      message += '\trequest body is cut, run with TESTOMATIO_DEBUG=1 to see full body\n';
+    }
+
+    console.log(message);
+
+    if (error.response?.data?.message?.includes('could not be matched')) {
+      this.hasUnmatchedTests = true;
+    }
+  }
+
   toString() {
     return 'Testomatio Reporter';
   }
 }
 
 let registeredErrorHints = false;
-function printCreateIssue(err) {
+function printCreateIssue() {
   if (registeredErrorHints) return;
   registeredErrorHints = true;
   process.on('exit', () => {
-    console.log();
-    console.log(APP_PREFIX, 'There was an error reporting to Testomat.io:');
     console.log(
       APP_PREFIX,
-      'If you think this is a bug please create an issue: https://github.com/testomatio/reporter/issues/new',
+      'There was an error reporting to Testomat.io.\n',
+      pc.yellow(
+        'If you think this is a bug please create an issue: https://github.com/testomatio/reporter/issues/new.',
+      ),
+      pc.yellow('Provide the logs from above'),
     );
-    console.log(APP_PREFIX, 'Provide this information:');
-    console.log('Error:', err.message || err.code);
-    if (!err.config) return;
-
-    const time = new Date().toUTCString();
-    const { body, url, baseURL, method } = err?.config || {};
-    console.log('```js');
-    console.log({ body: body?.replace(/"(tstmt_[^"]+)"/g, 'tstmt_*'), url, baseURL, method, time });
-    console.log('```');
   });
 }
 
+/**
+ * Removes Testomatio token from string data
+ *
+ * @param {string} data
+ * @returns {string}
+ */
+function hideTestomatioToken(data) {
+  return (typeof data === 'string' ? data : '')
+    .replace(/"api_key"\s*:\s*"[^"]+"/g, '"api_key": "<hidden>"')
+    .replace(/"(tstmt_[^"]+)"/g, '"tstmt_***"');
+}
+
+/**
+ * Stringifies provided data
+ *
+ * @param {any} anything
+ * @param {{ pretty: boolean }} opts
+ * @returns {string}
+ */
+function stringify(anything, opts = { pretty: false }) {
+  return typeof anything === 'string' ? anything : JSON.stringify(anything, null, opts.pretty ? 2 : undefined);
+}
+
 export default TestomatioPipe;

package/src/reporter-functions.js

@@ -1,5 +1,7 @@
+import { playwrightLogsMarkers } from './adapter/utils/playwright.js';
 import { isPlaywright } from './helpers.js';
 import { services } from './services/index.js';
+import pc from 'picocolors';
 
 /**
  * Stores path to file as artifact and uploads it to the S3 storage
@@ -8,7 +10,10 @@ import { services } from './services/index.js';
  * @returns {void}
  */
 function saveArtifact(data, context = null) {
-  showPlaywrightWarning('artifact', 'Playwright supports artifacts out of the box.');
+  if (isPlaywright)
+    console.warn(`[TESTOMATIO] 'artifact' function is not supported for Playwright
+   Playwright supports artifacts out of the box.`);
+
   if (!data) return;
   services.artifacts.put(data, context);
 }
@@ -41,59 +46,102 @@ function addStep(message, logs) {
 
 /**
  * Add key-value pair(s) to the test report
- * @param {{[key: string]: string} | string} keyValue - object { key: value } (multiple props allowed) or key (string)
- * @param {string|null} [value=null] - optional value when keyValue is a string
+ * @param {{[key: string]: string} | string} keyValue - object { key: value } (multiple props allowed) OR key (string)
+ * @param {string|undefined} [value=undefined] - optional value when keyValue is a string
  * @returns {void}
+ *
+ * @example
+ * meta('key', 'value');
+ * meta({ key: 'value' });
+ * meta({ key1: 'value1', key2: 'value2' });
  */
-function setKeyValue(keyValue, value = null) {
-  showPlaywrightWarning('meta', 'Use test annotations instead.');
-
+function setKeyValue(keyValue, value = undefined) {
+  // in this case keyValue acts as key (value passed as second argument)
   if (typeof keyValue === 'string') {
-    keyValue = { [keyValue]: value };
+    const key = keyValue;
+    keyValue = { [key]: value };
+  }
+
+  if (isPlaywright) {
+    console.log(`${playwrightLogsMarkers.meta} ${JSON.stringify(keyValue)}`);
+    return;
   }
+
+  // in this case keyValue is expected to be an object
   services.keyValues.put(keyValue);
 }
 
 /**
- * Add a single label to the test report
- * @param {string} key - label key (e.g. 'severity', 'feature', or just 'smoke' for labels without values)
- * @param {string|null} [value=null] - optional label value (e.g. 'high', 'login')
+ * Adds label(s) to the test
+ * @param {string | {
+ * [key: string]: string}
+ * } key - just label OR custom field name OR object with custom field name and value
+ * @param {string | null} [value=null] - optional label value (of custom field value)
+ * (used when key is a string)
  * @returns {void}
+ *
+ * @example
+ * label('high');
+ * label('priority', 'high');
+ * label({priority: 'high'});
  */
 function setLabel(key, value = null) {
-  showPlaywrightWarning('label', 'Use test tag instead.');
-  if (Array.isArray(value)) {
-    return value.forEach(label => setLabel(key, label));
+  let labelsArr = [];
+
+  // process label('priority', 'high') and label('high'
+  if (typeof key === 'string') {
+    labelsArr = [value ? `${key}:${value}` : key];
+    // process label({priority: 'high'}), label({priority: 'high', scope: 'smoke'})
+  } else if (key !== null && typeof key === 'object') {
+    labelsArr = Object.entries(key).map(([key, value]) => `${key}:${value}`);
+  }
+
+  const labels = labelsArr.map(l => ({ label: l }));
+  if (isPlaywright) {
+    console.log(`${playwrightLogsMarkers.label} ${JSON.stringify(labels)}`);
+    return;
   }
-  const labelObject =
-    value !== null && value !== undefined && value !== '' ? { label: `${key}:${value}` } : { label: key };
-  services.links.put([labelObject]);
+  services.links.put(labels);
 }
 
 /**
  * Add link(s) to the test report
- * @param {...string} testIds - test IDs to link
+ * @param {...string | string[]} testIds - test IDs to link
  * @returns {void}
+ *
+ * @example
+ * linkTest('T11111111', 'T22222222')
+ * or
+ * linkTest(['T11111111', 'T22222222'])
  */
 function linkTest(...testIds) {
-  const links = testIds.map(testId => ({ test: testId }));
+  const testIdsArr = testIds.flat();
+  const links = testIdsArr.map(testId => ({ test: testId }));
+  if (isPlaywright) {
+    console.log(`${playwrightLogsMarkers.linkTest} ${JSON.stringify(links)}`);
+    return;
+  }
   services.links.put(links);
 }
 
 /**
  * Add JIRA issue link(s) to the test report
- * @param {...string} jiraIds - JIRA issue IDs to link
+ * @param {...(string | string[])} jiraIds - JIRA issue IDs to link
  * @returns {void}
+ *
+ * @example
+ * linkJira('TICKET-1', 'TICKET-2')
+ * or
+ * linkJira(['TICKET-1', 'TICKET-2'])
  */
 function linkJira(...jiraIds) {
-  const links = jiraIds.map(jiraId => ({ jira: jiraId }));
-  services.links.put(links);
-}
-
-function showPlaywrightWarning(functionName, recommendation) {
+  const jiraIdsArr = jiraIds.flat();
+  const links = jiraIdsArr.map(jiraId => ({ jira: jiraId }));
   if (isPlaywright) {
-    console.warn(`[TESTOMATIO] '${functionName}' function is not supported for Playwright. ${recommendation}`);
+    console.log(`${playwrightLogsMarkers.linkJira} ${JSON.stringify(links)}`);
+    return;
   }
+  services.links.put(links);
 }
 
 export default {

package/src/services/links.js

@@ -30,7 +30,7 @@ class LinkStorage {
   /**
    * Returns links array for the test
    * @param {*} context testId or test context from test runner
-   * @returns {object[]} links array, e.g. [{test: 'TEST-123'}, {jira: 'JIRA-456'}]
+   * @returns {{[key: 'test' | 'jira']: string}[]} links array, e.g. [{test: 'TEST-123'}, {jira: 'JIRA-456'}]
    */
   get(context = null) {
     const linksList = dataStorage.getData('links', context);