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

package/lib/client.js

@@ -130,9 +130,12 @@ class Client {
       steps,
       code = null,
       title,
+      file,
       suite_title,
       suite_id,
       test_id,
+      manuallyAttachedArtifacts,
+      meta,
     } = testData;
     let { message = '' } = testData;
 
@@ -146,18 +149,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()) {
@@ -177,6 +175,7 @@ class Client {
       status,
       stack: fullLogs,
       example,
+      file,
       code,
       title,
       suite_title,
@@ -185,7 +184,7 @@ class Client {
       message,
       run_time: parseFloat(time),
       artifacts,
-      // meta: keyValues,
+      meta,
     };
 
     debug('Adding test run...', data);
@@ -251,9 +250,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;
   }
 

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/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 { services } = require('./services');
 
-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
+  testomatioLogger: services.logger,
 
-module.exports.testomat = {
   artifact: reporterFunctions.artifact,
   log: reporterFunctions.log,
-  step: reporterFunctions.step,
+  logger: services.logger,
   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);
+  },
+};

package/lib/{storages/key-value-storage.js → services/key-values.js}

@@ -1,17 +1,11 @@
-const debug = require('debug')('@testomatio/reporter:key-value-storage');
-const DataStorage = require('./data-storage');
+const debug = require('debug')('@testomatio/reporter:services-key-value');
+const { dataStorage } = require('../data-storage');
 
 class KeyValueStorage {
   static #instance;
 
-  #context;
-
-  constructor() {
-    this.dataStorage = new DataStorage('keyvalue');
-  }
-
   /**
-   * 
+   *
    * @returns {KeyValueStorage}
    */
   static getInstance() {
@@ -21,20 +15,14 @@ class KeyValueStorage {
     return this.#instance;
   }
 
-  /**
-   * @param {string} context - suite title + test title
-   */
-  setContext(context) {
-    this.#context = context;
-  }
-
   /**
    * Stores key-value pair and passes it to reporter
    * @param {{key: string}} keyValue - key-value pair(s) as object
+   * @param {*} context - full test title
    */
-  put(keyValue) {
+  put(keyValue, context = null) {
     if (!keyValue) return;
-    this.dataStorage.putData(keyValue, this.#context);
+    dataStorage.putData('keyvalue', keyValue, context);
   }
 
   #isKeyValueObject(smth) {
@@ -44,14 +32,11 @@ class KeyValueStorage {
   /**
    * Returns key-values pairs for the test as object
    * @param {*} context testId or test context from test runner
-   * @returns {Object} key-values pairs as object, e.g. {priority: 'high', browser: 'chrome'}
+   * @returns {{[key: string]: string} | {}} key-values pairs as object, e.g. {priority: 'high', browser: 'chrome'}
    */
   get(context = null) {
-    context = context || this.#context;
-    if (!context) return null;
-
-    const keyValuesList = this.dataStorage.getData(context);
-    if (!keyValuesList || !keyValuesList?.length) return null;
+    const keyValuesList = dataStorage.getData('keyvalue', context);
+    if (!keyValuesList || !keyValuesList?.length) return {};
 
     const keyValues = {};
     for (const keyValue of keyValuesList) {
@@ -66,7 +51,7 @@ class KeyValueStorage {
       }
     }
 
-    return Object.keys(keyValues).length ? keyValues : null;
+    return keyValues;
   }
 }