@testomatio/reporter 1.1.1-beta-codecept-logger → 1.1.1-file-upload.1

package/lib/client.js

@@ -27,6 +27,7 @@ class Client {
     this.pipes = pipesFactory(params, store);
     this.queue = Promise.resolve();
     this.totalUploaded = 0;
+    this.failedToUpload = 0;
     this.version = JSON.parse(fs.readFileSync(join(__dirname, '..', 'package.json')).toString()).version;
     this.executionList = Promise.resolve();
 
@@ -130,9 +131,12 @@ class Client {
       steps,
       code = null,
       title,
+      file,
       suite_title,
       suite_id,
       test_id,
+      manuallyAttachedArtifacts,
+      meta,
     } = testData;
     let { message = '' } = testData;
 
@@ -146,18 +150,13 @@ class Client {
     // 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()) {
@@ -165,11 +164,14 @@ 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) {
+      const failedUploading = uploadedFiles.length - artifacts.length;
+      this.failedToUpload += failedUploading;
+    }
 
-    this.totalUploaded += uploadedFiles.filter(n => n).length;
+    this.totalUploaded += artifacts.length;
 
     const data = {
       files,
@@ -177,6 +179,7 @@ class Client {
       status,
       stack: fullLogs,
       example,
+      file,
       code,
       title,
       suite_title,
@@ -185,7 +188,7 @@ class Client {
       message,
       run_time: parseFloat(time),
       artifacts,
-      // meta: keyValues,
+      meta,
     };
 
     debug('Adding test run...', data);
@@ -234,6 +237,16 @@ class Client {
               process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
             } uploaded to S3 bucket`,
           );
+
+          if (this.failedToUpload > 0) {
+            console.log(
+              APP_PREFIX,
+              chalk.yellow(
+                `Some artifacts were not uploaded. ${this.failedToUpload} artifacts could not be uploaded. Run tests with DEBUG="@testomatio/reporter:file-uploader" to see details"`,
+              ),
+            );
+          }
+    
         }
       })
       .catch(err => console.log(APP_PREFIX, err));
@@ -251,9 +264,9 @@ class Client {
     logs = logs?.trim();
 
     let testLogs = '';
-    if (steps) testLogs += `${chalk.bold.blue('################[ Steps ]################')}\n${steps}`;
-    if (logs) testLogs += `\n\n${chalk.bold.gray('################[ Logs ]################')}\n${logs}`;
-    if (error) testLogs += `\n\n${chalk.bold.red('################[ Failure ]################')}\n${error}`;
+    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;
   }
 
@@ -296,6 +309,7 @@ class Client {
 
 function isNotInternalFrame(frame) {
   return (
+    frame.getFileName() &&
     frame.getFileName().includes(sep) &&
     !frame.getFileName().includes('node_modules') &&
     !frame.getFileName().includes('internal')

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/{storages/data-storage.js → data-storage.js}

@@ -3,25 +3,38 @@ 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 } = require('../utils/utils');
+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 for specific data type.
-   * Stores data to global variable or to file depending on what is applicable for current test runner
+   * 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).
-   * But the data storage itself is not singleton. It will have an instance per data type.
-   * @param {'log' | 'artifact' | 'keyvalue'} dataType – type of data to store
    */
-  constructor(dataType) {
-    this.dataType = dataType || 'data';
-
+  constructor() {
     // some frameworks use global variable to store data, some use file storage
     this.isFileStorage = true;
-
-    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, this.dataType);
   }
 
   #stringToFilename(str) {
@@ -37,23 +50,28 @@ class DataStorage {
   /**
    * 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(data, context = null) {
-    fileSystem.createDir(this.dataDirPath);
+  putData(dataType, data, context = null) {
+    if (!dataType || !data) return;
+
+    context = context || this.context || global.testomatioTestTitle || jestHelpers.getIdOfCurrentlyRunningTest();
     if (!context) {
-      debug(`No context provided for "${this.dataType}" data:`, data);
+      debug(`No context provided for "${dataType}" data:`, data);
       return;
     }
     context = this.#stringToFilename(context);
 
     if (this.isFileStorage) {
-      this.#putDataToFile(data, context);
+      const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
+      fileSystem.createDir(dataDirPath);
+      this.#putDataToFile(dataType, data, context);
     } else {
-      this.#putDataToGlobalVar(data, context);
+      this.#putDataToGlobalVar(dataType, data, context);
     }
   }
 
@@ -61,12 +79,16 @@ class DataStorage {
    * 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 []} of data (any type), null (if no data found for test) or string (if data type is log)
+   * @returns {any []} array of data (any type), null (if no data found for context) or string (if data type is log)
    */
-  getData(context) {
+  getData(dataType, context) {
+    // TODO: think if it could be useful
+    // context = context || this.context || global.testomatioTestTitle || jestHelpers.getIdOfCurrentlyRunningTest();
+
     if (!context) {
-      debug(`No context passed`, context);
+      debug(`Trying to get "${dataType}" data without context`);
       return null;
     }
 
@@ -76,36 +98,37 @@ class DataStorage {
     let testDataFromGlobalVar = [];
 
     if (global?.testomatioDataStore) {
-      testDataFromGlobalVar = this.#getDataFromGlobalVar(context);
+      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(context);
+    testDataFromFile = this.#getDataFromFile(dataType, context);
 
     if (testDataFromFile.length) {
       return testDataFromFile;
     }
-    debug(`No "${this.dataType}" data for test id ${context} in both file and global variable`);
+    debug(`No "${dataType}" data for context "${context}" in both file and global variable`);
 
-    // in case no data found for test
+    // in case no data found for context
     return null;
   }
 
   /**
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
    * @param {string} context
    * @returns aray of data (any type)
    */
-  #getDataFromGlobalVar(context) {
+  #getDataFromGlobalVar(dataType, context) {
     try {
-      if (global?.testomatioDataStore[this.dataType]) {
-        const testData = global.testomatioDataStore[this.dataType][context];
-        if (testData) debug(`"${this.dataType}" data for test id ${context}:`, testData.join(', '));
+      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 test context ${context} in <global> storage`);
+      // debug(`No ${this.dataType} data for context ${context} in <global> storage`);
       return [];
     } catch (e) {
       // there could be no data, ignore
@@ -113,20 +136,21 @@ class DataStorage {
   }
 
   /**
-   *
+   * @param {'log' | 'artifact' | 'keyvalue'} dataType
    * @param {*} context
    * @returns array of data (any type)
    */
-  #getDataFromFile(context) {
+  #getDataFromFile(dataType, context) {
+    const dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, dataType);
     try {
-      const filepath = join(this.dataDirPath, `${this.dataType}_${context}`);
+      const filepath = join(dataDirPath, `${dataType}_${context}`);
       if (fs.existsSync(filepath)) {
         const testDataAsText = fs.readFileSync(filepath, 'utf-8');
-        if (testDataAsText) debug(`"${this.dataType}" data for test id ${context}:`, testDataAsText);
+        if (testDataAsText) debug(`"${dataType}" data for context "${context}":`, testDataAsText);
         const testDataArr = testDataAsText?.split(os.EOL) || [];
         return testDataArr;
       }
-      // debug(`No ${this.dataType} data for test ${context} in <file> storage`);
+      // debug(`No ${this.dataType} data for ${context} in <file> storage`);
       return [];
     } catch (e) {
       // there could be no data, ignore
@@ -136,24 +160,33 @@ class DataStorage {
 
   /**
    * 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(data, context) {
+  #putDataToGlobalVar(dataType, data, context) {
     debug('Saving data to global variable for ', context, ':', data);
     if (!global.testomatioDataStore) global.testomatioDataStore = {};
-    if (!global.testomatioDataStore?.[this.dataType]) global.testomatioDataStore[this.dataType] = {};
+    if (!global.testomatioDataStore?.[dataType]) global.testomatioDataStore[dataType] = {};
 
-    if (!global.testomatioDataStore?.[this.dataType][context]) global.testomatioDataStore[this.dataType][context] = [];
-    global.testomatioDataStore[this.dataType][context].push(data);
+    if (!global.testomatioDataStore?.[dataType][context]) global.testomatioDataStore[dataType][context] = [];
+    global.testomatioDataStore[dataType][context].push(data);
   }
 
-  #putDataToFile(data, context) {
+  /**
+   * 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 = `${this.dataType}_${context}`;
-    const filepath = join(this.dataDirPath, filename);
-    if (!fs.existsSync(this.dataDirPath)) fileSystem.createDir(this.dataDirPath);
-    debug('Saving data to file for', context, 'to', filepath, ':\n', data, '\n');
+    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)) {
@@ -164,7 +197,7 @@ class DataStorage {
   }
 }
 
-module.exports = DataStorage;
+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

@@ -11,7 +11,6 @@ const readFile = util.promisify(fs.readFile);
 const stat = util.promisify(fs.stat);
 const chalk = require('chalk');
 const { randomUUID } = require('crypto');
-const memoize = require('lodash.memoize');
 
 const { APP_PREFIX } = require('./constants');
 
@@ -146,8 +145,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 +283,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;
@@ -295,8 +297,8 @@ const getS3LocationLink = async (out) => {
 };
 
 module.exports = {
-  uploadFileByPath: memoize(uploadFileByPath),
-  uploadFileAsBuffer: memoize(uploadFileAsBuffer),
+  uploadFileByPath,
+  uploadFileAsBuffer,
   isArtifactsEnabled,
   resetConfig,
 };

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;
@@ -175,13 +176,14 @@ class TestomatioPipe {
    * @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);
 
+    debug('Adding test', json);
+
     return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, {
       maxContentLength: Infinity,
       maxBodyLength: Infinity,

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,7 +19,7 @@ function saveArtifact(data, context = null) {
  * @param  {...any} args
  */
 function logMessage(...args) {
-  logger.log(...args);
+  services.logger.templateLiteralLog(...args);
 }
 
 /**
@@ -24,7 +27,7 @@ function logMessage(...args) {
  * @param {*} message
  */
 function addStep(message) {
-  logger.step(message);
+  services.logger.step(message);
 }
 
 /**
@@ -32,17 +35,7 @@ function addStep(message) {
  * @param {*} keyValue
  */
 function setKeyValue(keyValue) {
-  keyValueStorage.put(keyValue);
-}
-
-/**
- *
- * @param {string} context – test id or test title or suite title + test title
- */
-function _setContext(context) {
-  logger.setContext(context);
-  keyValueStorage.setContext(context);
-  artifactStorage.setContext(context);
+  services.keyValues.put(keyValue);
 }
 
 module.exports = {
@@ -50,5 +43,4 @@ module.exports = {
   log: logMessage,
   step: addStep,
   keyValue: setKeyValue,
-  _setContext,
 };

package/lib/reporter.js

@@ -1,24 +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,
-  _setContext: reporterFunctions._setContext,
+  step: reporterFunctions.step,
+
+  TestomatClient,
+  TRConstants,
 };
+

package/lib/{storages/artifact-storage.js → services/artifacts.js}

@@ -1,5 +1,5 @@
-const debug = require('debug')('@testomatio/reporter:artifact-storage');
-const DataStorage = require('./data-storage');
+const debug = require('debug')('@testomatio/reporter:services-artifacts');
+const { dataStorage } = require('../data-storage');
 
 /**
  * Artifact storage is supposed to store file paths
@@ -7,18 +7,6 @@ const DataStorage = require('./data-storage');
 class ArtifactStorage {
   static #instance;
 
-  #context;
-
-  // 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
    * @returns {ArtifactStorage}
@@ -30,39 +18,28 @@ class ArtifactStorage {
     return this.#instance;
   }
 
-  /**
-   * @param {string} context - suite title + test title
-   */
-  setContext(context) {
-    this.#context = context;
-  }
-
   /**
    * 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) {
-    context = context || this.#context;
     if (!data) return;
     debug('Save artifact:', data);
-    this.dataStorage.putData(data, context);
+    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}[]}
+   * @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;
+    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
+      // artifact could be an object ({type, path, name} props) or string (just path)
       let artifact;
       try {
         artifact = JSON.parse(artifactData);
@@ -72,7 +49,8 @@ class ArtifactStorage {
       return artifact;
     });
     artifacts = artifacts.filter(artifact => !!artifact);
-    return artifacts.length ? artifacts : null;
+    debug(`Artifacts for test ${context}:`, artifacts);
+    return artifacts.length ? artifacts : [];
   }
 }
 

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);
+  },
+};