@testomatio/reporter 2.0.0-beta-esm → 2.0.1-beta-esm

package/src/client.js

@@ -4,24 +4,26 @@ import { minimatch } from 'minimatch';
 import fs from 'fs';
 import pc from 'picocolors';
 import { randomUUID } from 'crypto';
-import {upload} from './fileUploader.js';
 import { APP_PREFIX, STATUS } from './constants.js';
 import { pipesFactory } from './pipe/index.js';
 import { glob } from 'glob';
-import path, { sep} from 'path';
+import path, { sep } from 'path';
 import { fileURLToPath } from 'node:url';
+import { S3Uploader } from './uploader.js';
+import { formatStep, storeRunId } from './utils/utils.js';
+import { filesize as prettyBytes } from 'filesize';
 
 const debug = createDebugMessages('@testomatio/reporter:client');
 
 // removed __dirname usage, because:
 // 1. replaced with ESM syntax (import.meta.url), but it throws an error on tsc compilation;
-// 2. got error "__dirname already defined" in compiles js code (cjs dir) 
+// 2. got error "__dirname already defined" in compiles js code (cjs dir)
 
 let listOfTestFilesToExcludeFromReport = null;
 
 /**
- * @typedef {import('../types').TestData} TestData
- * @typedef {import('../types').PipeResult} PipeResult
+ * @typedef {import('../types/types.js').TestData} TestData
+ * @typedef {import('../types/types.js').PipeResult} PipeResult
  */
 
 class Client {
@@ -29,12 +31,12 @@ class Client {
    * Create a Testomat client instance
    * @returns
    */
-  // eslint-disable-next-line 
+  // eslint-disable-next-line
   constructor(params = {}) {
-    this.uuid = randomUUID();
+    this.paramsForPipesFactory = params;
+    this.pipeStore = {};
+    this.runId = randomUUID(); // will be replaced by real run id
     this.queue = Promise.resolve();
-    this.totalUploaded = 0;
-    this.failedToUpload = 0;
 
     // @ts-ignore this line will be removed in compiled code, because __dirname is defined in commonjs
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -47,6 +49,7 @@ class Client {
     }
     this.executionList = Promise.resolve();
 
+    this.uploader = new S3Uploader();
   }
 
   /**
@@ -66,8 +69,7 @@ class Client {
    * or resolves to undefined if no valid results are found or if all pipes are disabled.
    */
   async prepareRun(params) {
-    const store = {};
-    this.pipes = await pipesFactory(params, store);
+    this.pipes = await pipesFactory(params || this.paramsForPipesFactory || {}, this.pipeStore);
     const { pipe, pipeOptions } = params;
     // all pipes disabled, skipping
     if (!this.pipes.some(p => p.isEnabled)) {
@@ -110,7 +112,8 @@ class Client {
    * @returns {Promise<any>} - resolves to Run id which should be used to update / add test
    */
   async createRun(params) {
-    if (!this.pipes || !this.pipes.length) this.pipes = await pipesFactory(params || {}, {});
+    if (!this.pipes || !this.pipes.length)
+      this.pipes = await pipesFactory(params || this.paramsForPipesFactory || {}, this.pipeStore);
     debug('Creating run...');
     // all pipes disabled, skipping
     if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
@@ -118,6 +121,12 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun())))
       .catch(err => console.log(APP_PREFIX, err))
+      .then(() => {
+        const runId = this.pipeStore?.runId;
+        if (runId) this.runId = runId;
+        storeRunId(this.runId);
+      })
+      .then(() => this.uploader.checkEnabled())
       .then(() => undefined); // fixes return type
     // debug('Run', this.queue);
     return this.queue;
@@ -165,9 +174,45 @@ class Client {
       suite_id,
       test_id,
       manuallyAttachedArtifacts,
-      meta,
     } = testData;
-    let { message = '' } = testData;
+    let { message = '', meta = {} } = testData;
+
+    // stringify meta values and limit keys and values length to 255
+    meta = Object.entries(meta)
+      .filter(([, value]) => value !== null && value !== undefined)
+      .map(([key, value]) => {
+        try {
+          if (typeof value === 'object') {
+            value = JSON.stringify(value);
+          } else if (typeof value !== 'string') {
+            try {
+              value = value.toString();
+            } catch (err) {
+              console.warn(APP_PREFIX, `Can't convert meta value to string`, err);
+            }
+          }
+
+          if (value?.length > 255) {
+            value = value.substring(0, 255);
+            debug(APP_PREFIX, `Meta info value "${value}" is too long, trimmed to 255 characters`);
+          }
+
+          if (key?.length > 255) {
+            const newKey = key.substring(0, 255);
+            debug(APP_PREFIX, `Meta info key "${key}" is too long, trimmed to 255 characters`);
+            return [newKey, value];
+          }
+
+          return [key, value];
+        } catch (err) {
+          debug(APP_PREFIX, `Error while processing meta info key ${key}`, err);
+          return [null, null];
+        }
+      })
+      .reduce((acc, [key, value]) => {
+        if (key) acc[key] = value;
+        return acc;
+      }, {});
 
     let errorFormatted = '';
     if (error) {
@@ -183,24 +228,24 @@ class Client {
 
     const uploadedFiles = [];
 
-    for (const f of files) {
-      uploadedFiles.push(upload.uploadFileByPath(f, this.uuid));
+    for (let f of files) {
+      if (!f) continue; // f === null
+      if (typeof f === 'object') {
+        if (!f.path) continue;
+
+        f = f.path;
+      }
+
+      uploadedFiles.push(this.uploader.uploadFileByPath(f, [this.runId, rid, path.basename(f)]));
     }
 
     for (const [idx, buffer] of filesBuffers.entries()) {
       const fileName = `${idx + 1}-${title.replace(/\s+/g, '-')}`;
-      uploadedFiles.push(upload.uploadFileAsBuffer(buffer, fileName, this.uuid));
+      uploadedFiles.push(this.uploader.uploadFileAsBuffer(buffer, [this.runId, rid, fileName]));
     }
 
     const artifacts = (await Promise.all(uploadedFiles)).filter(n => !!n);
 
-    if (artifacts.length < uploadedFiles.length) {
-      const failedUploading = uploadedFiles.length - artifacts.length;
-      this.failedToUpload += failedUploading;
-    }
-
-    this.totalUploaded += artifacts.length;
-
     const data = {
       rid,
       files,
@@ -258,27 +303,81 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug('TOTAL artifacts', this.totalUploaded);
-        if (this.totalUploaded && !upload.isArtifactsEnabled())
-          debug(`${this.totalUploaded} artifacts are not uploaded, because artifacts uploading is not enabled`);
+        if (!this.uploader.isEnabled) return;
+
+        const filesizeStrMaxLength = 7;
+
+        if (this.uploader.successfulUploads.length) {
+          debug('\n', APP_PREFIX, `🗄️ ${this.uploader.successfulUploads.length} artifacts uploaded to S3 bucket`);
+          const uploadedArtifacts = this.uploader.successfulUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            link: file.link,
+            sizePretty: prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+
+          uploadedArtifacts.forEach(upload => {
+            debug(
+              `🟢Uploaded artifact`,
+              `${upload.relativePath},`,
+              'size:',
+              `${upload.sizePretty},`,
+              'link:',
+              `${upload.link}`,
+            );
+          });
+        }
 
-        if (this.totalUploaded && upload.isArtifactsEnabled()) {
+        if (this.uploader.failedUploads.length) {
           console.log(
             APP_PREFIX,
-            `🗄️ ${this.totalUploaded} artifacts ${
-              process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : pc.bold('publicly')
-            } uploaded to S3 bucket`,
+            `🗄️ ${this.uploader.failedUploads.length} artifacts 🔴${pc.bold('failed')} to upload`,
           );
+          const failedUploads = this.uploader.failedUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            sizePretty: prettyBytes(file.size, { round: 0 }).toString(),
+          }));
 
-          if (this.failedToUpload > 0) {
+          const pathPadding = Math.max(...failedUploads.map(upload => upload.relativePath.length)) + 1;
+
+          failedUploads.forEach(upload => {
             console.log(
-              APP_PREFIX,
-              pc.yellow(
-                `Some artifacts were not uploaded. ${this.failedToUpload} artifacts could not be uploaded.
-                Run tests with DEBUG="@testomatio/reporter:file-uploader" to see details"`,
-              ),
+              `  ${pc.gray('|')} 🔴 ${upload.relativePath.padEnd(pathPadding)} ${pc.gray(
+                `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+              )}`,
             );
-          }
+          });
+        }
+
+        if (this.uploader.skippedUploads.length) {
+          console.log(
+            '\n',
+            APP_PREFIX,
+            `🗄️ ${pc.bold(this.uploader.skippedUploads.length)} artifacts uploading 🟡${pc.bold('skipped')}`,
+          );
+          const skippedUploads = this.uploader.skippedUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            sizePretty: file.size === null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+          const pathPadding = Math.max(...skippedUploads.map(upload => upload.relativePath.length)) + 1;
+          skippedUploads.forEach(upload => {
+            console.log(
+              `  ${pc.gray('|')} 🟡 ${upload.relativePath.padEnd(pathPadding)} ${pc.gray(
+                `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+              )}`,
+            );
+          });
+        }
+
+        if (this.uploader.skippedUploads.length || this.uploader.failedUploads.length) {
+          const command = `TESTOMATIO=<your_api_key> TESTOMATIO_RUN=${
+            this.runId
+          } npx @testomatio/reporter upload-artifacts`;
+          const numberOfNotUploadedArtifacts = this.uploader.skippedUploads.length + this.uploader.failedUploads.length;
+          console.log(
+            APP_PREFIX,
+            `${numberOfNotUploadedArtifacts} artifacts were not uploaded.
+            Run "${pc.magenta(command)}" with valid S3 credentials to upload skipped & failed artifacts`,
+          );
         }
       })
       .catch(err => console.log(APP_PREFIX, err));
@@ -365,24 +464,6 @@ function isNotInternalFrame(frame) {
   );
 }
 
-function formatStep(step, shift = 0) {
-  const prefix = ' '.repeat(shift);
-
-  const lines = [];
-
-  if (step.error) {
-    lines.push(`${prefix}${pc.red(step.title)} ${pc.gray(`${step.duration}ms`)}`);
-  } else {
-    lines.push(`${prefix}${step.title} ${pc.gray(`${step.duration}ms`)}`);
-  }
-
-  for (const child of step.steps || []) {
-    lines.push(...formatStep(child, shift + 2));
-  }
-
-  return lines;
-}
-
 /**
  *
  * @param {TestData} testData

package/src/constants.js

@@ -3,7 +3,11 @@ import os from 'os';
 import path from 'path';
 
 const APP_PREFIX = pc.gray('[TESTOMATIO]');
-const AXIOS_TIMEOUT = 20 * 1000; // sum = 20sec
+const TESTOMATIO_REQUEST_TIMEOUT = parseInt(process.env.TESTOMATIO_REQUEST_TIMEOUT, 10);
+if (TESTOMATIO_REQUEST_TIMEOUT) {
+  console.log(`${APP_PREFIX} Request timeout is set to ${TESTOMATIO_REQUEST_TIMEOUT / 1000}s`);
+}
+const AXIOS_TIMEOUT = TESTOMATIO_REQUEST_TIMEOUT || 20 * 1000;
 
 const TESTOMAT_TMP_STORAGE_DIR = path.join(os.tmpdir(), 'testomatio_tmp');
 

package/src/data-storage.js

@@ -52,7 +52,7 @@ class DataStorage {
 
     context = context || this.context || testRunnerHelper.getNameOfCurrentlyRunningTest();
     if (!context) {
-      debug(`No context provided for "${dataType}" data:`, data);
+      // debug(`No context provided for "${dataType}" data:`, data);
       return;
     }
     const contextHash = stringToMD5Hash(context);
@@ -101,7 +101,7 @@ class DataStorage {
     if (testDataFromFile.length) {
       return testDataFromFile;
     }
-    debug(`No "${dataType}" data for context "${contextHash}" in both file and global variable`);
+    // debug(`No "${dataType}" data for context "${contextHash}" in both file and global variable`);
 
     // in case no data found for context
     return null;

package/src/pipe/bitbucket.js

@@ -15,8 +15,8 @@ const debug = createDebugMessages('@testomatio/reporter:pipe:bitbucket');
 
 /**
  * @class BitbucketPipe
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  */
 export class BitbucketPipe {
   constructor(params, store = {}) {

package/src/pipe/csv.js

@@ -1,7 +1,7 @@
 import createDebugMessages from 'debug';
 import path from 'path';
 import fs from 'fs';
-import {createObjectCsvWriter} from 'csv-writer';
+import { createObjectCsvWriter } from 'csv-writer';
 import pc from 'picocolors';
 import merge from 'lodash.merge';
 import { isSameTest, getCurrentDateTime, ansiRegExp } from '../utils/utils.js';
@@ -9,8 +9,8 @@ import { CSV_HEADERS } from '../constants.js';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:csv');
 /**
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  * @class CsvPipe
  * @implements {Pipe}
  */

package/src/pipe/debug.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import createDebugMessages from 'debug';
+import { APP_PREFIX } from '../constants.js';
+import prettyMs from 'pretty-ms';
+
+const debug = createDebugMessages('@testomatio/reporter:pipe:debug');
+
+export class DebugPipe {
+  constructor(params, store) {
+    this.params = params || {};
+    this.store = store || {};
+
+    this.isEnabled = !!process.env.TESTOMATIO_DEBUG || !!process.env.DEBUG;
+    if (this.isEnabled) {
+      this.batch = {
+        isEnabled: this.params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+        intervalFunction: null,
+        intervalTime: 5000,
+        tests: [],
+        batchIndex: 0,
+      };
+      this.logFilePath = path.join(os.tmpdir(), `testomatio.debug.${Date.now()}.json`);
+
+      debug('Creating debug file:', this.logFilePath);
+      fs.writeFileSync(this.logFilePath, '');
+      console.log(APP_PREFIX, '🪲. Debug created:');
+      this.testomatioEnvVars = Object.keys(process.env)
+        .filter(key => key.startsWith('TESTOMATIO_'))
+        .reduce((acc, key) => {
+          acc[key] = process.env[key];
+          return acc;
+        }, {});
+      this.logToFile({ datetime: new Date().toISOString(), timestamp: Date.now() });
+      this.logToFile({ data: 'variables', testomatioEnvVars: this.testomatioEnvVars });
+      this.logToFile({ data: 'store', store: this.store || {} });
+      // Bind batchUpload to the instance
+      this.batchUpload = this.batchUpload.bind(this);
+    }
+  }
+
+  /**
+   * Logs data to a file if logging is enabled.
+   *
+   * @param {Object} logData - The data to be logged.
+   * @returns {Promise<void>} A promise that resolves when the log data has been appended to the file.
+   */
+  logToFile(logData) {
+    if (!this.isEnabled) return;
+    const timePassedFromLastAction = Date.now() - (this.lastActionTimestamp || Date.now());
+    this.lastActionTimestamp = Date.now();
+
+    const logLine = JSON.stringify({ t: `+${prettyMs(timePassedFromLastAction)}`, ...logData });
+    fs.appendFileSync(this.logFilePath, `${logLine}\n`);
+  }
+
+  async prepareRun(opts) {
+    if (!this.isEnabled) return [];
+
+    this.logToFile({ action: 'prepareRun', data: opts });
+  }
+
+  async createRun(params = {}) {
+    if (!this.isEnabled) return;
+    if (params.isBatchEnabled === true || params.isBatchEnabled === false) this.batch.isEnabled = params.isBatchEnabled;
+
+    if (!this.isEnabled) return {};
+    if (this.batch.isEnabled) this.batch.intervalFunction = setInterval(this.batchUpload, this.batch.intervalTime);
+
+    this.logToFile({ action: 'createRun', params });
+  }
+
+  async addTest(data) {
+    if (!this.isEnabled) return;
+
+    if (!this.batch.isEnabled) this.logToFile({ action: 'addTest', testId: data });
+    else this.batch.tests.push(data);
+
+    if (!this.batch.intervalFunction) await this.batchUpload();
+  }
+
+  async batchUpload() {
+    this.batch.batchIndex++;
+    if (!this.batch.isEnabled) return;
+    if (!this.batch.tests.length) return;
+
+    const testsToSend = this.batch.tests.splice(0);
+
+    this.logToFile({ action: 'addTestsBatch', tests: testsToSend });
+  }
+
+  async finishRun(params) {
+    if (!this.isEnabled) return;
+    this.logToFile({ actions: 'finishRun', params });
+    await this.batchUpload();
+    if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
+    console.log(APP_PREFIX, '🪲. Debug Saved to', this.logFilePath);
+  }
+
+  toString() {
+    return 'Debug Reporter';
+  }
+}

package/src/pipe/github.js

@@ -10,10 +10,9 @@ import { statusEmoji, fullName } from '../utils/pipe_utils.js';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:github');
 
-
 /**
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  * @class GitHubPipe
  * @implements {Pipe}
  */

package/src/pipe/gitlab.js

@@ -15,8 +15,8 @@ const debug = createDebugMessages('@testomatio/reporter:pipe:gitlab');
 
 /**
  * @class GitLabPipe
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  */
 class GitLabPipe {
   constructor(params, store = {}) {
@@ -81,13 +81,13 @@ class GitLabPipe {
     let summary = `${this.hiddenCommentData}
     
   | [![Testomat.io Report](${testomatLogoURL})](https://testomat.io)  | ${statusEmoji(
-      runParams.status,
-    )} ${runParams.status.toUpperCase()} ${statusEmoji(runParams.status)} |
+    runParams.status,
+  )} ${runParams.status.toUpperCase()} ${statusEmoji(runParams.status)} |
   | --- | --- |
   | Tests | ✔️  **${this.tests.length}** tests run  |
   | Summary | ${statusEmoji('failed')} **${failedCount}** failed; ${statusEmoji(
-      'passed',
-    )} **${passedCount}** passed; **${statusEmoji('skipped')}** ${skippedCount} skipped |
+    'passed',
+  )} **${passedCount}** passed; **${statusEmoji('skipped')}** ${skippedCount} skipped |
   | Duration | 🕐  **${humanizeDuration(
     parseInt(
       this.tests.reduce((a, t) => a + (t.run_time || 0), 0),

package/src/pipe/html.js

@@ -5,9 +5,9 @@ import path from 'path';
 import pc from 'picocolors';
 import handlebars from 'handlebars';
 import fileUrl from 'file-url';
-import { fileSystem, isSameTest, ansiRegExp } from '../utils/utils.js';
+import { fileSystem, isSameTest, ansiRegExp, formatStep } from '../utils/utils.js';
 import { HTML_REPORT } from '../constants.js';
-import { fileURLToPath } from "node:url";
+import { fileURLToPath } from 'node:url';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:html');
 
@@ -72,7 +72,7 @@ class HtmlPipe {
 
   /**
    * Add test data to the result array for saving. As a result of this function, we get a result object to save.
-   * @param {import('../../types').RunData} test - object which includes each test entry.
+   * @param {import('../../types/types.js').RunData} test - object which includes each test entry.
    */
   addTest(test) {
     if (!this.isEnabled) return;
@@ -128,6 +128,14 @@ class HtmlPipe {
     }
 
     tests.forEach(test => {
+      // steps could be an array or a string
+      test.steps = Array.isArray(test.steps)
+        ? (test.steps = test.steps
+            .map(step => formatStep(step))
+            .flat()
+            .join('\n'))
+        : test.steps;
+
       if (!test.message?.trim()) {
         test.message = "This test has no 'message' code";
       }

package/src/pipe/index.js

@@ -7,7 +7,8 @@ import GitHubPipe from './github.js';
 import GitLabPipe from './gitlab.js';
 import CsvPipe from './csv.js';
 import HtmlPipe from './html.js';
-import {BitbucketPipe} from './bitbucket.js';
+import { BitbucketPipe } from './bitbucket.js';
+import { DebugPipe } from './debug.js';
 
 export async function pipesFactory(params, opts) {
   const extraPipes = [];
@@ -47,6 +48,7 @@ export async function pipesFactory(params, opts) {
     new CsvPipe(params, opts),
     new HtmlPipe(params, opts),
     new BitbucketPipe(params, opts),
+    new DebugPipe(params, opts),
     ...extraPipes,
   ];
 
@@ -55,13 +57,9 @@ export async function pipesFactory(params, opts) {
   console.log(
     APP_PREFIX,
     pc.cyan('Pipes:'),
-    pc.cyan(
-      pipesEnabled
-        .map(p => p.toString())
-        .join(', ') || 'No pipes enabled',
-    ),
+    pc.cyan(pipesEnabled.map(p => p.toString()).join(', ') || 'No pipes enabled'),
   );
-  
+
   if (!pipesEnabled.length) {
     console.log(
       APP_PREFIX,