@testomatio/reporter 1.1.0-beta.mocha-create.9 → 1.1.0-rc.2

package/lib/client.js

@@ -1,14 +1,13 @@
 const debug = require('debug')('@testomatio/reporter:client');
 const createCallsiteRecord = require('callsite-record');
 const { sep, join } = require('path');
-const { minimatch } = require('minimatch')
+const { minimatch } = require('minimatch');
 const fs = require('fs');
 const chalk = require('chalk');
 const { randomUUID } = require('crypto');
 const upload = require('./fileUploader');
 const { APP_PREFIX } = require('./constants');
 const pipesFactory = require('./pipe');
-const artifactStorage = require('./storages/artifact-storage');
 
 /**
  * @typedef {import('../types').TestData} TestData
@@ -36,7 +35,7 @@ class Client {
 
   /**
    * Asynchronously prepares the execution list for running tests through various pipes.
-   * Each pipe in the client is checked for enablement, 
+   * Each pipe in the client is checked for enablement,
    * and if all pipes are disabled, the function returns a resolved Promise.
    * Otherwise, it executes the `prepareRun` method for each enabled pipe and collects the results.
    * The results are then filtered to remove any undefined values.
@@ -46,7 +45,7 @@ class Client {
    * @param {Object} params - The options for preparing the test execution list.
    * @param {string} params.pipe - Name of the executed pipe.
    * @param {string} params.pipeOptions - Filter option.
-   * @returns {Promise<any>} - A Promise that resolves to an 
+   * @returns {Promise<any>} - A Promise that resolves to an
    * array containing the prepared execution list,
    * or resolves to undefined if no valid results are found or if all pipes are disabled.
    */
@@ -63,22 +62,22 @@ class Client {
       if (!filterPipe.isEnabled) {
         // TODO:for the future for the another pipes
         console.warn(
-          APP_PREFIX, 
-          `At the moment processing is available only for the "testomatio" key. Example: "testomatio:tag-name=xxx"`
+          APP_PREFIX,
+          `At the moment processing is available only for the "testomatio" key. Example: "testomatio:tag-name=xxx"`,
         );
         return;
       }
 
-      const results = await Promise.all(this.pipes.map(async p => 
-        ({ pipe: p.toString(), result: await p.prepareRun(pipeOptions) })  
-      ));
-    
+      const results = await Promise.all(
+        this.pipes.map(async p => ({ pipe: p.toString(), result: await p.prepareRun(pipeOptions) })),
+      );
+
       const result = results.filter(p => p.pipe.includes('Testomatio'))[0]?.result;
 
       if (!result || result.length === 0) {
         return;
-      } 
-  
+      }
+
       debug('Execution tests list', result);
 
       return result;
@@ -135,41 +134,28 @@ class Client {
       suite_title,
       suite_id,
       test_id,
+      manuallyAttachedArtifacts,
+      meta,
     } = testData;
     let { message = '' } = testData;
 
-    const uploadedFiles = [];
-
-    let stack = '';
 
+    let errorFormatted = '';
     if (error) {
-      stack = this.formatError(error) || '';
+      errorFormatted += this.formatError(error) || '';
       message = error?.message;
     }
-    if (steps) {
-      stack = this.formatSteps(stack, steps);
-    }
-
-    stack += testData.stack || '';
 
-    // ATTACH LOGS from storage
-    // in some cases (e.g. using cucumber) logger instance becomes empty object, if import at the top of the file
-    const logger = require('./storages/logger');
-    const testLogs = logger.getLogs(test_id);
-    // debug(`Test logs for ${test_id}:\n`, testLogs);
-    if (stack) stack += '\n\n';
-    stack += testLogs ? `${chalk.bold('Logs:')}\n${testLogs}` : '';
+    // Attach logs
+    const fullLogs = this.formatLogs({ error: errorFormatted, steps, logs: testData.logs });
 
-    // GET ARTIFACTS from storage
-    const artifactFiles = artifactStorage.get(test_id);
-    if (artifactFiles) files.push(...artifactFiles);
+    // add artifacts
+    if (manuallyAttachedArtifacts?.length) files.push(...manuallyAttachedArtifacts);
 
-    // GET KEY-VALUEs from storage
-    const keyValueStorage = require('./storages/key-value-storage');
-    const keyValues = keyValueStorage.get(test_id);
+    const uploadedFiles = [];
 
-    for (const file of files) {
-      uploadedFiles.push(upload.uploadFileByPath(file, this.uuid));
+    for (const f of files) {
+      uploadedFiles.push(upload.uploadFileByPath(f, this.uuid));
     }
 
     for (const [idx, buffer] of filesBuffers.entries()) {
@@ -177,9 +163,16 @@ class Client {
       uploadedFiles.push(upload.uploadFileAsBuffer(buffer, fileName, this.uuid));
     }
 
-    const artifacts = await Promise.all(uploadedFiles);
+    const artifacts = (await Promise.all(uploadedFiles)).filter(n => !!n);
 
-    // global.testomatioArtifacts = [];
+    if (artifacts.length < uploadedFiles.length) {
+      console.log(
+        APP_PREFIX,
+        chalk.yellow(
+          `Some artifacts were not uploaded. ${artifacts.length}/${uploadedFiles.length} artifacts uploaded.`,
+        ),
+      );
+    }
 
     this.totalUploaded += uploadedFiles.filter(n => n).length;
 
@@ -187,7 +180,7 @@ class Client {
       files,
       steps,
       status,
-      stack,
+      stack: fullLogs,
       example,
       file,
       code,
@@ -198,9 +191,11 @@ class Client {
       message,
       run_time: parseFloat(time),
       artifacts,
-      meta: keyValues,
+      meta,
     };
 
+    debug('Adding test run...', data);
+
     this.queue = this.queue.then(() =>
       Promise.all(
         this.pipes.map(async p => {
@@ -252,15 +247,27 @@ class Client {
     return this.queue;
   }
 
-  formatSteps(stack, steps) {
-    return stack ? `${steps}\n\n${chalk.bold.red('################[ Failure ]################')}\n${stack}` : steps;
+  /**
+   * Returns the formatted stack including the stack trace, steps, and logs.
+   * @returns {string}
+   */
+  formatLogs({ error, steps, logs }) {
+    error = error?.trim();
+    steps = steps?.trim();
+    logs = logs?.trim();
+
+    let testLogs = '';
+    if (steps) testLogs += `${chalk.bold.blue('################[ Steps ]################')}\n${steps}\n\n`;
+    if (logs) testLogs += `${chalk.bold.gray('################[ Logs ]################')}\n${logs}\n\n`;
+    if (error) testLogs += `${chalk.bold.red('################[ Failure ]################')}\n${error}`;
+    return testLogs;
   }
 
   formatError(error, message) {
     if (!message) message = error.message;
     if (error.inspect) message = error.inspect() || '';
 
-    let stack = `\n${chalk.bold(message)}\n`;
+    let stack = `${message}\n`;
 
     // diffs for mocha, cypress, codeceptjs style
     if (error.actual && error.expected) {
@@ -277,11 +284,11 @@ class Client {
       const record = createCallsiteRecord({
         forError: error,
         isCallsiteFrame: frame => {
-          if (customFilter && minimatch(frame.getFileName(), customFilter)) return false;          
+          if (customFilter && minimatch(frame.getFileName(), customFilter)) return false;
           if (hasFrame) return false;
           if (isNotInternalFrame(frame)) hasFrame = true;
           return hasFrame;
-        }
+        },
       });
       if (record && !record.filename.startsWith('http')) {
         stack += record.renderSync({ stackFilter: isNotInternalFrame });
@@ -294,9 +301,11 @@ class Client {
 }
 
 function isNotInternalFrame(frame) {
-  return frame.getFileName().includes(sep) &&
+  return (
+    frame.getFileName().includes(sep) &&
     !frame.getFileName().includes('node_modules') &&
     !frame.getFileName().includes('internal')
+  );
 }
 
 module.exports = Client;

package/lib/config.js

@@ -8,6 +8,10 @@ const debug = require('debug')('@testomatio/reporter:config');
 const dotenv = require('dotenv');
 const envFileVars = dotenv.config({ path: '.env' }).parsed; */
 
+const TESTOMATIO = process.env.TESTOMATIO || process.env.TESTOMATIO_API_KEY || process.env.TESTOMATIO_TOKEN || '';
+if (TESTOMATIO === 'undefined') console.error('TESTOMATIO is "undefined". Something went wrong. Contact dev team.');
+process.env.TESTOMATIO = TESTOMATIO;
+
 // select only TESTOMATIO related variables (only to print them in debug)
 const testomatioEnvVars =
   Object.keys(process.env)
@@ -22,3 +26,4 @@ debug('TESTOMATIO variables:', testomatioEnvVars);
 const config = process.env;
 
 module.exports = config;
+module.exports.TESTOMATIO = TESTOMATIO;

package/lib/data-storage.js

@@ -0,0 +1,203 @@
+const debug = require('debug')('@testomatio/reporter:storage');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { join } = require('path');
+const { TESTOMAT_TMP_STORAGE_DIR } = require('./constants');
+const { fileSystem, jestHelpers } = require('./utils/utils');
+
+class DataStorage {
+  static #instance;
+
+  context;
+
+  /**
+   *
+   * @returns {DataStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new DataStorage();
+    }
+    return this.#instance;
+  }
+
+  setContext(context) {
+    this.context = context;
+  }
+
+  /**
+   * Creates data storage instance as singleton
+   * Stores data to global variable or to file depending on what is applicable for current test runner (adapter)
+   * Recommend to use composition while using this class (instead of inheritance).
+   * ! Also the class which will use data storage should be singleton (to avoid data loss).
+   */
+  constructor() {
+    // some frameworks use global variable to store data, some use file storage
+    this.isFileStorage = true;
+  }
+
+  #stringToFilename(str) {
+    // TODO: use md5 hash later
+    const validFilenameRegex = /[^a-zA-Z0-9_.-]/g;
+    // replace all characters not in the regex above with underscore, then duplicate underscores removed
+    let filename = str.replace(validFilenameRegex, '_').replace(/_{2,}/g, '_').substring(0, 255); // max filename length
+    // remove leading and trailing underscores
+    filename = filename.replace(/^_+|_+$/g, '');
+    return filename;
+  }
+
+  /**
+   * Puts any data to storage (file or global variable).
+   * If file: stores data as text, if global variable – stores as array of data.
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
+   * @param {*} data anything you want to store (string, object, array, etc)
+   * @param {*} context could be testId or any context (test name, suite name, including their IDs etc)
+   * suite name + test name is used by default
+   * @returns
+   */
+  putData(dataType, data, context = null) {
+    if (!dataType || !data) return;
+
+    context = context || this.context || global.testomatioTestTitle || jestHelpers.getIdOfCurrentlyRunningTest();
+    if (!context) {
+      debug(`No context provided for "${dataType}" data:`, data);
+      return;
+    }
+    context = this.#stringToFilename(context);
+
+    if (this.isFileStorage) {
+      const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+      fileSystem.createDir(dataDirPath);
+      this.#putDataToFile(dataType, data, context);
+    } else {
+      this.#putDataToGlobalVar(dataType, data, context);
+    }
+  }
+
+  /**
+   * Returns data, stored for specific test/context (or data which was stored without test id specified).
+   * This method will get data from global variable and/or from from file (previosly saved with put method).
+   *
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
+   * @param {string} context
+   * @returns {any []} array of data (any type), null (if no data found for context) or string (if data type is log)
+   */
+  getData(dataType, context) {
+    // TODO: think if it could be useful
+    // context = context || this.context || global.testomatioTestTitle || jestHelpers.getIdOfCurrentlyRunningTest();
+
+    if (!context) {
+      debug(`Trying to get "${dataType}" data without context`);
+      return null;
+    }
+
+    context = this.#stringToFilename(context);
+
+    let testDataFromFile = [];
+    let testDataFromGlobalVar = [];
+
+    if (global?.testomatioDataStore) {
+      testDataFromGlobalVar = this.#getDataFromGlobalVar(dataType, context);
+      if (testDataFromGlobalVar) {
+        if (testDataFromGlobalVar.length) return testDataFromGlobalVar;
+      }
+      // don't return nothing if no data in global variable
+    }
+
+    testDataFromFile = this.#getDataFromFile(dataType, context);
+
+    if (testDataFromFile.length) {
+      return testDataFromFile;
+    }
+    debug(`No "${dataType}" data for context "${context}" in both file and global variable`);
+
+    // in case no data found for context
+    return null;
+  }
+
+  /**
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
+   * @param {string} context
+   * @returns aray of data (any type)
+   */
+  #getDataFromGlobalVar(dataType, context) {
+    try {
+      if (global?.testomatioDataStore[dataType]) {
+        const testData = global.testomatioDataStore[dataType][context];
+        if (testData) debug(`"${dataType}" data for constext "${context}":`, testData.join(', '));
+        return testData || [];
+      }
+      // debug(`No ${this.dataType} data for context ${context} in <global> storage`);
+      return [];
+    } catch (e) {
+      // there could be no data, ignore
+    }
+  }
+
+  /**
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
+   * @param {*} context
+   * @returns array of data (any type)
+   */
+  #getDataFromFile(dataType, context) {
+    const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+    try {
+      const filepath = join(dataDirPath, `${dataType}_${context}`);
+      if (fs.existsSync(filepath)) {
+        const testDataAsText = fs.readFileSync(filepath, 'utf-8');
+        if (testDataAsText) debug(`"${dataType}" data for context "${context}":`, testDataAsText);
+        const testDataArr = testDataAsText?.split(os.EOL) || [];
+        return testDataArr;
+      }
+      // debug(`No ${this.dataType} data for ${context} in <file> storage`);
+      return [];
+    } catch (e) {
+      // there could be no data, ignore
+    }
+    return [];
+  }
+
+  /**
+   * Puts data to global variable. Unlike the file storage, stores data in array (file storage just append as string).
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
+   * @param {*} data
+   * @param {*} context
+   */
+  #putDataToGlobalVar(dataType, data, context) {
+    debug('Saving data to global variable for ', context, ':', data);
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+    if (!global.testomatioDataStore?.[dataType]) global.testomatioDataStore[dataType] = {};
+
+    if (!global.testomatioDataStore?.[dataType][context]) global.testomatioDataStore[dataType][context] = [];
+    global.testomatioDataStore[dataType][context].push(data);
+  }
+
+  /**
+   * Puts data to file. Unlike the global variable storage, stores data as string
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
+   * @param {*} data
+   * @param {string} context
+   * @returns
+   */
+  #putDataToFile(dataType, data, context) {
+    const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+    if (typeof data !== 'string') data = JSON.stringify(data);
+    const filename = `${dataType}_${context}`;
+    const filepath = join(dataDirPath, filename);
+    if (!fs.existsSync(dataDirPath)) fileSystem.createDir(dataDirPath);
+    debug(`Saving data to file for context "${context}" to ${filepath}. Data: ${JSON.stringify(data)}`);
+
+    // append new line if file already exists (in this case its definitely includes some data)
+    if (fs.existsSync(filepath)) {
+      fs.appendFileSync(filepath, os.EOL + data, 'utf-8');
+    } else {
+      fs.writeFileSync(filepath, data, 'utf-8');
+    }
+  }
+}
+
+module.exports.dataStorage = DataStorage.getInstance();
+
+// TODO: consider using fs promises instead of writeSync/appendFileSync to
+// prevent blocking and improve performance (probably queue usage will be required)

package/lib/fileUploader.js

@@ -146,8 +146,13 @@ const uploadUsingS3 = async (filePath, runId) => {
       params
     });
 
-    return await getS3LocationLink(out);
-  } 
+    
+    const link = await getS3LocationLink(out);
+    
+    debug(`Succesfully uploaded ${filePath} => ${S3_BUCKET}/${Key} | URL: ${link}`);
+
+    return link;
+  }
   catch (e) {
     debug('S3 file uploading error: ', e);
    
@@ -279,8 +284,6 @@ const getS3LocationLink = async (out) => {
 
   let s3Location = response?.Location;
 
-  debug('Uploaded response.Location', s3Location);
-
   if (!s3Location) {
     // TODO: out: a fallback case  - remove after deeper testing
     s3Location = out?.singleUploadResult?.Location;

package/lib/junit-adapter/index.js

@@ -6,8 +6,7 @@ const RubyAdapter = require('./ruby');
 const CSharpAdapter = require('./csharp');
 
 function AdapterFactory(lang, opts) {
-  if (!lang) return new Adapter(opts);
-
+  
   if (lang === 'java') {
     return new JavaAdapter(opts);
   }
@@ -23,6 +22,8 @@ function AdapterFactory(lang, opts) {
   if (lang === 'c#' || lang === 'csharp') {
     return new CSharpAdapter(opts);
   }
+  
+  return new Adapter(opts);
 }
 
 module.exports = AdapterFactory;

package/lib/pipe/testomatio.js

@@ -5,6 +5,7 @@ const JsonCycle = require('json-cycle');
 const { APP_PREFIX, STATUS } = require('../constants');
 const { isValidUrl, foundedTestLog } = require('../utils/utils');
 const { parseFilterParams, generateFilterRequestParams, setS3Credentials, } = require('../utils/pipe_utils');
+const { TESTOMATIO } = require('../config');
 
 if (process.env.TESTOMATIO_RUN) {
   process.env.runId = process.env.TESTOMATIO_RUN;
@@ -20,7 +21,7 @@ class TestomatioPipe {
   constructor(params, store) {
     this.isEnabled = false;
     this.url = params.testomatioUrl || process.env.TESTOMATIO_URL || 'https://app.testomat.io';
-    this.apiKey = params.apiKey || process.env.TESTOMATIO;
+    this.apiKey = params.apiKey || TESTOMATIO;
     debug('Testomatio Pipe: ', this.apiKey ? 'API KEY' : '*no api key*');
     if (!this.apiKey) {
       return;

package/lib/reporter-functions.js

@@ -1,6 +1,9 @@
-const logger = require('./storages/logger');
-const artifactStorage = require('./storages/artifact-storage');
-const keyValueStorage = require('./storages/key-value-storage');
+const { services } = require('./services');
+const { initPlaywrightForStorage } = require('./adapter/playwright');
+
+if (process.env.PLAYWRIGHT_TEST_BASE_URL) {
+  initPlaywrightForStorage();
+}
 
 /**
  * Stores path to file as artifact and uploads it to the S3 storage
@@ -8,7 +11,7 @@ const keyValueStorage = require('./storages/key-value-storage');
  */
 function saveArtifact(data, context = null) {
   if (!data) return;
-  artifactStorage.put(data, context);
+  services.artifacts.put(data, context);
 }
 
 /**
@@ -16,23 +19,23 @@ function saveArtifact(data, context = null) {
  * @param  {...any} args
  */
 function logMessage(...args) {
-  logger.log(...args);
+  services.logger.templateLiteralLog(...args);
 }
 
 /**
  * Similar to "log" function but marks message in report as a step
- * @param {*} message 
+ * @param {*} message
  */
 function addStep(message) {
-  logger.step(message);
+  services.logger.step(message);
 }
 
 /**
  * Add key-value pair(s) to the test report
- * @param {*} keyValue 
+ * @param {*} keyValue
  */
 function setKeyValue(keyValue) {
-  keyValueStorage.put(keyValue);
+  services.keyValues.put(keyValue);
 }
 
 module.exports = {

package/lib/reporter.js

@@ -1,23 +1,19 @@
-const logger = require('./storages/logger');
 const TestomatClient = require('./client');
 const TRConstants = require('./constants');
 
-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,
-};
+  // TODO: deprecate in future; use log or testomat.log
+  logger: reporterFunctions.log,
+  testomatioLogger: reporterFunctions.log,
 
-module.exports.testomat = {
   artifact: reporterFunctions.artifact,
   log: reporterFunctions.log,
-  step: reporterFunctions.step,
   meta: reporterFunctions.keyValue,
+  step: reporterFunctions.step,
+
+  TestomatClient,
+  TRConstants,
 };
+

package/lib/services/artifacts.js

@@ -0,0 +1,57 @@
+const debug = require('debug')('@testomatio/reporter:services-artifacts');
+const { dataStorage } = require('../data-storage');
+
+/**
+ * Artifact storage is supposed to store file paths
+ */
+class ArtifactStorage {
+  static #instance;
+
+  /**
+   * Singleton
+   * @returns {ArtifactStorage}
+   */
+  static getInstance() {
+    if (!this.#instance) {
+      this.#instance = new ArtifactStorage();
+    }
+    return this.#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);
+    dataStorage.putData('artifact', 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) {
+    let artifacts = dataStorage.getData('artifact', context);
+    if (!artifacts || !artifacts.length) return [];
+
+    artifacts = artifacts.map(artifactData => {
+      // artifact could be an object ({type, path, name} props) or string (just path)
+      let artifact;
+      try {
+        artifact = JSON.parse(artifactData);
+      } catch (e) {
+        artifact = artifactData;
+      }
+      return artifact;
+    });
+    artifacts = artifacts.filter(artifact => !!artifact);
+    debug(`Artifacts for test ${context}:`, artifacts);
+    return artifacts.length ? artifacts : [];
+  }
+}
+
+module.exports.artifactStorage = ArtifactStorage.getInstance();

package/lib/services/index.js

@@ -0,0 +1,13 @@
+const { logger } = require('./logger');
+const { artifactStorage } = require('./artifacts');
+const { keyValueStorage } = require('./key-values');
+const { dataStorage } = require('../data-storage');
+
+module.exports.services = {
+  logger,
+  artifacts: artifactStorage,
+  keyValues: keyValueStorage,
+  setContext: context => {
+    dataStorage.setContext(context);
+  },
+};