@testomatio/reporter 1.0.17 → 1.0.18-beta.1

package/Changelog.md

@@ -1,4 +1,8 @@
 <!-- pending release updates -->
+# 1.0.18
+
+* Fixed stack traces for CodeceptJS
+
 # 1.0.17
 
 Renamed `TESTOMATIO_STACK_FILTER` to `TESTOMATIO_STACK_IGNORE`

package/lib/adapter/codecept.js

@@ -1,7 +1,7 @@
 const debug = require('debug')('@testomatio/reporter:adapter:codeceptjs');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
-const { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
 const upload = require('../fileUploader');
 const { parseTest: getIdFromTestTitle, fileSystem } = require('../utils/utils');
 
@@ -56,7 +56,7 @@ function CodeceptReporter(config) {
   // Listening to events
   event.dispatcher.on(event.all.before, () => {
     // clear tmp dir
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
 
     recorder.add('Creating new run', () => client.createRun());
     videos = [];
@@ -147,9 +147,6 @@ function CodeceptReporter(config) {
     failedTests.push(id || title);
     let testId = parseTest(tags);
     const testObj = getTestAndMessage(title);
-    if (error && error.stack && test.steps && test.steps.length) {
-      error.stack = test.steps[test.steps.length - 1].line();
-    }
 
     const files = [];
     if (artifacts.screenshot) files.push({ path: artifacts.screenshot, type: 'image/png' });

package/lib/adapter/cucumber/current.js

@@ -2,9 +2,9 @@
 const { Formatter, formatterHelpers } = require('@cucumber/cucumber');
 const chalk = require('chalk');
 const fs = require('fs');
-const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../../constants');
 const TestomatClient = require('../../client');
-const logger = require('../../logger');
+const logger = require('../../storages/logger');
 const { parseTest, fileSystem } = require('../../utils/utils');
 
 const { GherkinDocumentParser, PickleParser } = formatterHelpers;
@@ -37,7 +37,7 @@ class CucumberReporter extends Formatter {
 
   parseEnvelope(envelope) {
     if (envelope.testRunStarted) {
-      fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+      fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
     }
     if (envelope.testCaseStarted && this.client) {
       this.client.createRun();

package/lib/adapter/cucumber/legacy.js

@@ -2,7 +2,7 @@
 const { Formatter } = require('cucumber');
 const chalk = require('chalk');
 const { parseTest, fileSystem } = require('../../utils/utils');
-const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../../constants');
 const TestomatClient = require('../../client');
 
 const createTestomatFormatter = apiKey => {
@@ -97,7 +97,7 @@ const createTestomatFormatter = apiKey => {
 
       options.eventBroadcaster.on('gherkin-document', addDocument);
       options.eventBroadcaster.on('test-run-started', () => {
-        fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+        fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
         this?.client?.createRun();
       });
       options.eventBroadcaster.on('test-case-finished', this.onTestCaseFinished.bind(this));

package/lib/adapter/jest.js

@@ -1,5 +1,5 @@
 const TestomatClient = require('../client');
-const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
 const { parseTest, ansiRegExp, fileSystem } = require('../utils/utils');
 
 class JestReporter {
@@ -11,20 +11,9 @@ class JestReporter {
     this.client.createRun();
   }
 
-  static getIdOfCurrentlyRunningTest() {
-    if (!process.env.JEST_WORKER_ID) return null;
-    try {
-      // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
-      // eslint-disable-next-line no-undef
-      if (expect && expect?.getState()?.currentTestName) return parseTest(expect?.getState()?.currentTestName); 
-    } catch (e) {
-      return null; 
-    }
-  }
-
   onRunStart() {
     // clear tmp dir
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
   }
 
   onTestResult(test, testResult) {
@@ -72,9 +61,6 @@ class JestReporter {
     const { numFailedTests } = results;
     const status = numFailedTests === 0 ? STATUS.PASSED : STATUS.FAILED;
     this.client.updateRunStatus(status);
-
-    // clear tmp dir
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
   }
 }
 

package/lib/adapter/mocha.js

@@ -1,11 +1,9 @@
 // eslint-disable-next-line global-require, import/no-extraneous-dependencies
 const Mocha = require('mocha');
-const debug = require('debug')('@testomatio/reporter:adapter:mocha');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
-const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
-const { parseTest, specificTestInfo, fileSystem } = require('../utils/utils');
-const ArtifactStorage = require('../_ArtifactStorageOld');
+const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
+const { parseTest, fileSystem } = require('../utils/utils');
 
 const { EVENT_RUN_BEGIN, EVENT_RUN_END, EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING } =
   Mocha.Runner.constants;
@@ -15,7 +13,7 @@ function MochaReporter(runner, opts) {
   let passes = 0;
   let failures = 0;
   let skipped = 0;
-  let artifactStore;
+  // let artifactStore;
 
   const apiKey = opts?.reporterOptions?.apiKey || process.env.TESTOMATIO;
 
@@ -24,13 +22,7 @@ function MochaReporter(runner, opts) {
   runner.on(EVENT_RUN_BEGIN, () => {
     client.createRun();
 
-    const params = {
-      toFile: true,
-    };
-
-    artifactStore = runner._workerReporter !== undefined ? new ArtifactStorage(params) : new ArtifactStorage();
-
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
   });
 
   runner.on(EVENT_TEST_PASS, async test => {
@@ -38,20 +30,11 @@ function MochaReporter(runner, opts) {
     console.log(chalk.bold.green('✔'), test.fullTitle());
     const testId = parseTest(test.title);
 
-    const specificTest = specificTestInfo(test);
-    const content = await artifactStore.artifactByTestName(specificTest);
-
-    debug(`test=${specificTest} content = `, content);
-
-    client.addTestRun(
-      STATUS.PASSED,
-      {
-        test_id: testId,
-        title: test.title,
-        time: test.duration,
-      },
-      content,
-    );
+    client.addTestRun(STATUS.PASSED, {
+      test_id: testId,
+      title: test.title,
+      time: test.duration,
+    });
   });
 
   runner.on(EVENT_TEST_PENDING, test => {
@@ -70,29 +53,18 @@ function MochaReporter(runner, opts) {
     console.log(chalk.bold.red('✖'), test.fullTitle(), chalk.gray(err.message));
     const testId = parseTest(test.title);
 
-    const specificTest = specificTestInfo(test);
-    const content = await artifactStore.artifactByTestName(specificTest);
-
-    debug(`fail test=${specificTest} content = `, content);
-
-    client.addTestRun(
-      STATUS.FAILED,
-      {
-        error: err,
-        test_id: testId,
-        title: test.title,
-        time: test.duration,
-      },
-      content,
-    );
+    client.addTestRun(STATUS.FAILED, {
+      error: err,
+      test_id: testId,
+      title: test.title,
+      time: test.duration,
+    });
   });
 
   runner.on(EVENT_RUN_END, () => {
     const status = failures === 0 ? STATUS.PASSED : STATUS.FAILED;
     console.log(chalk.bold(status), `${passes} passed, ${failures} failed, ${skipped} skipped`);
     client.updateRunStatus(status);
-
-    artifactStore.cleanup();
   });
 }
 

package/lib/adapter/playwright.js

@@ -3,7 +3,7 @@ const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
-const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
 const TestomatioClient = require('../client');
 const { isArtifactsEnabled } = require('../fileUploader');
 const { parseTest, fileSystem } = require('../utils/utils');
@@ -19,15 +19,17 @@ class PlaywrightReporter {
 
   onBegin(_config, suite) {
     // clean data storage
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
     if (!this.client) return;
     this.suite = suite;
     this.client.createRun();
   }
 
-  // onTestBegin(test) {
-  //   const testId = parseTest(test.title);
-  // }
+  /*
+  onTestBegin(test) {
+    // does not work; value is not to the storage context
+    global.testTitle = test.title;
+  } */
 
   onTestEnd(test, result) {
     if (!this.client) return;
@@ -44,23 +46,33 @@ class PlaywrightReporter {
       appendStep(step, steps);
     }
 
-    const logs = `\n\n${chalk.bold('Logs:')}\n${chalk.red(result.stderr.join(''))}\n${result.stdout.join('')}`;
-
-    const reportTestPromise = this.client.addTestRun(checkStatus(result.status), {
-      error,
-      test_id: testId,
-      suite_title,
-      title,
-      steps: steps.join('\n'),
-      time: duration,
-      stack: logs,
-    }).then(pipes => {
-      testId = pipes?.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
-
-      this.uploads.push({
-        testId, title, suite_title, files: result.attachments.filter((a) => a.body || a.path)
+    let logs = '';
+    if (result.stderr.length || result.stdout.length) {
+      logs = `\n\n${chalk.bold('Logs:')}\n${chalk.red(result.stderr.join(''))}\n${result.stdout.join('')}`;
+    }
+
+    const reportTestPromise = this.client
+      .addTestRun(checkStatus(result.status), {
+        error,
+        test_id: testId,
+        suite_title,
+        title,
+        steps: steps.join('\n'),
+        time: duration,
+        stack: logs,
+      })
+      .then(pipes => {
+        testId = pipes?.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
+
+        this.uploads.push({
+          testId,
+          title,
+          suite_title,
+          files: result.attachments.filter(a => a.body || a.path),
+        });
+        // remove empty uploads
+        this.uploads = this.uploads.filter(upload => upload.files.length);
       });
-    });
 
     reportTestPromises.push(reportTestPromise);
   }

package/lib/bin/startTest.js

@@ -53,6 +53,12 @@ program
 
     let exitCode = 0;
 
+    if (!command.split) {
+      process.exitCode = 255;
+      console.log(APP_PREFIX, `No command provided. Use -c option to launch a test runner.`);
+      return;
+    }
+
     const client = new TestomatClient({ apiKey, title, parallel: true });
 
     if(filter) {
@@ -74,12 +80,6 @@ program
       }
     }
 
-    if (!command.split) {
-      process.exitCode = 255;
-      console.log(APP_PREFIX, `No command provided. Use -c option to launch a test runner.`);
-      return;
-    }
-
     const testCmds = command.split(' ');
     console.log(APP_PREFIX, `🚀 Running`, chalk.green(command));
 

package/lib/client.js

@@ -8,6 +8,7 @@ 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
@@ -96,9 +97,6 @@ class Client {
     // all pipes disabled, skipping
     if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
-    global.testomatioArtifacts = [];
-    if (!global.testomatioDataStore) global.testomatioDataStore = {};
-
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun())))
       .catch(err => console.log(APP_PREFIX, err))
@@ -112,11 +110,9 @@ class Client {
    *
    * @param {string|undefined} status
    * @param {TestData} [testData]
-   * @param {string[]} [storeArtifacts]
    * @returns {Promise<PipeResult[]>}
    */
-  async addTestRun(status, testData, storeArtifacts = []) {
-    debug('Adding test run for test', testData?.test_id || 'unknown test');
+  async addTestRun(status, testData) {
     // all pipes disabled, skipping
     if (!this.pipes?.filter(p => p.isEnabled).length) return [];
 
@@ -155,23 +151,21 @@ class Client {
 
     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('./logger');
+    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}` : '';
 
-    if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
-      debug('CLIENT storeArtifact', storeArtifacts);
-      files.push(...storeArtifacts);
-    }
+    // GET ARTIFACTS from storage
+    const artifactFiles = artifactStorage.get(test_id);
+    if (artifactFiles) files.push(...artifactFiles);
 
-    if (Array.isArray(global.testomatioArtifacts)) {
-      debug('CLIENT global[testomatioArtifacts]', global.testomatioArtifacts);
-      files.push(...global.testomatioArtifacts);
-      global.testomatioArtifacts = [];
-    }
+    // GET KEY-VALUEs from storage
+    const keyValueStorage = require('./storages/key-value-storage');
+    const keyValues = keyValueStorage.get(test_id);
 
     for (const file of files) {
       uploadedFiles.push(upload.uploadFileByPath(file, this.uuid));
@@ -184,7 +178,7 @@ class Client {
 
     const artifacts = await Promise.all(uploadedFiles);
 
-    global.testomatioArtifacts = [];
+    // global.testomatioArtifacts = [];
 
     this.totalUploaded += uploadedFiles.filter(n => n).length;
 
@@ -202,6 +196,7 @@ class Client {
       message,
       run_time: parseFloat(time),
       artifacts,
+      meta: keyValues,
     };
 
     this.queue = this.queue.then(() =>
@@ -237,14 +232,16 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug('TOTAL uploaded files', this.totalUploaded);
+        debug('TOTAL artifacts', this.totalUploaded);
+        if (this.totalUploaded && !upload.isArtifactsEnabled())
+          debug(`${this.totalUploaded} artifacts are not uploaded, because artifacts uploading is not enabled`);
 
-        if (upload.isArtifactsEnabled() && this.totalUploaded > 0) {
+        if (this.totalUploaded && upload.isArtifactsEnabled()) {
           console.log(
             APP_PREFIX,
-            `🗄️  Total ${this.totalUploaded} artifacts ${
+            `🗄️ ${this.totalUploaded} artifacts ${
               process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
-            } uploaded to S3 bucket  `,
+            } uploaded to S3 bucket`,
           );
         }
       })

package/lib/constants.js

@@ -1,11 +1,10 @@
 const chalk = require('chalk');
+const os = require('os');
+const path = require('path');
 
 const APP_PREFIX = chalk.gray('[TESTOMATIO]');
-const TESTOMAT_ARTIFACT_SUFFIX = "testomatio_artifact_";
 
-const TESTOMAT_TMP_STORAGE = {
-  mainDir: "testomatio_tmp",
-}
+const TESTOMAT_TMP_STORAGE_DIR = path.join(os.tmpdir(), 'testomatio_tmp');
 
 const CSV_HEADERS = [
   { id: 'suite_title', title: 'Suite_title' },
@@ -24,8 +23,7 @@ const STATUS = {
 
 module.exports = {
   APP_PREFIX,
-  TESTOMAT_ARTIFACT_SUFFIX,
-  TESTOMAT_TMP_STORAGE,
+  TESTOMAT_TMP_STORAGE_DIR,
   CSV_HEADERS,
   STATUS,
 }

package/lib/reporter-functions.js

@@ -0,0 +1,43 @@
+const logger = require('./storages/logger');
+const artifactStorage = require('./storages/artifact-storage');
+const keyValueStorage = require('./storages/key-value-storage');
+
+/**
+ * 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
+ */
+function saveArtifact(data, context = null) {
+  if (!data) return;
+  artifactStorage.put(data, context);
+}
+
+/**
+ * Attach log message(s) to the test report
+ * @param  {...any} args
+ */
+function logMessage(...args) {
+  logger.log(...args);
+}
+
+/**
+ * Similar to "log" function but marks message in report as a step
+ * @param {*} message 
+ */
+function addStep(message) {
+  logger.step(message);
+}
+
+/**
+ * Add key-value pair(s) to the test report
+ * @param {*} keyValue 
+ */
+function setKeyValue(keyValue) {
+  keyValueStorage.put(keyValue);
+}
+
+module.exports = {
+  artifact: saveArtifact,
+  log: logMessage,
+  step: addStep,
+  keyValue: setKeyValue,
+};

package/lib/reporter.js

@@ -1,10 +1,10 @@
-const logger = require('./logger');
+const logger = require('./storages/logger');
 const TestomatClient = require('./client');
 const TRConstants = require('./constants');
-const TRArtifacts = require('./_ArtifactStorageOld');
 
 const log = logger.templateLiteralLog.bind(logger);
 const step = logger.step.bind(logger);
+const reporterFunctions = require('./reporter-functions');
 
 module.exports = {
   logger,
@@ -13,6 +13,11 @@ module.exports = {
   step,
   TestomatClient,
   TRConstants,
-  TRArtifacts,
-  addArtifact: TRArtifacts.artifact,
+};
+
+module.exports.testomat = {
+  artifact: reporterFunctions.artifact,
+  log: reporterFunctions.log,
+  step: reporterFunctions.step,
+  meta: reporterFunctions.keyValue,
 };

package/lib/storages/artifact-storage.js

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

package/lib/{dataStorage.js → storages/data-storage.js}

@@ -3,16 +3,18 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { join } = require('path');
-const JestReporter = require('./adapter/jest');
-const { TESTOMAT_TMP_STORAGE } = require('./constants');
-const { fileSystem } = require('./utils/utils');
-const getTestIdFromTestTitle = require('./utils/utils').parseTest;
+const { TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
+const { fileSystem, jestHelpers, parseTest } = require('../utils/utils');
+
+const getTestIdFromTestTitle = parseTest;
 
 class DataStorage {
   /**
    * 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
    * (running environment).
+   * 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).
    * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
    */
   constructor(dataType) {
@@ -20,8 +22,35 @@ class DataStorage {
     this.isFileStorage = true;
     this.#refreshStorageType();
 
-    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataType);
-    fileSystem.createDir(this.dataDirPath);
+    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, this.dataType);
+
+    // set test title for mocha (could not be moved to adapter)
+    // it does not override existing hook, just add new one
+    try {
+      // @ts-ignore
+      if (!beforeEach) return;
+      // @ts-ignore-next-line
+      beforeEach(function () {
+        if (this.currentTest?.__mocha_id__) {
+          global.testTitle = this.currentTest.fullTitle();
+        }
+      });
+    } catch (e) {
+      // ignore
+    }
+
+    // set test title for playwright
+    try {
+      // eslint-disable-next-line import/no-extraneous-dependencies, import/no-unresolved
+      const { test } = require('@playwright/test');
+      // eslint-disable-next-line no-empty-pattern
+      test.beforeEach(async ({}, testInfo) => {
+        global.testTitle = testInfo.title;
+        global.testomatioRunningEnvironment = 'playwright';
+      });
+    } catch (e) {
+      // ignore
+    }
   }
 
   /**
@@ -44,15 +73,18 @@ class DataStorage {
   }
 
   /**
-   * Puts any data to storage (file or global variable)
-   * @param {*} data anything you want to store
+   * Puts any data to storage (file or global variable).
+   * If file: stores data as text, if global variable – stores as array of data.
+   * @param {*} data anything you want to store (string, object, array, etc)
    * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
    * @returns
    */
   putData(data, context = null) {
-    this.#refreshStorageType();
+    fileSystem.createDir(this.dataDirPath);
 
-    let testId = this.#tryToRetrieveTestId(context) || null;
+    this.#refreshStorageType();
+    context = context ?? global.testTitle ?? null;
+    let testId = this.#tryToRetrieveTestId(context) || context || null;
 
     if (this.runningEnvironment === 'codeceptjs') {
       this.isFileStorage = false;
@@ -60,7 +92,7 @@ class DataStorage {
     }
 
     if (this.runningEnvironment === 'jest') {
-      testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
+      testId = testId ?? jestHelpers.getIdOfCurrentlyRunningTest();
     }
 
     // logs in playwright are gathered by pw framework itself
@@ -74,7 +106,7 @@ class DataStorage {
       testId = this.#tryToRetrieveTestId(global.currentlyRunningTestTitle);
 
     if (!testId) {
-      debug(`No test id provided for ${this.dataType} data: ${data}`);
+      debug(`No test id provided for "${this.dataType}" data:`, data);
       return;
     }
 
@@ -87,12 +119,10 @@ class DataStorage {
 
   /**
    * Returns data, stored for specific testId (or data which was stored without test id specified).
-   * This method will get data from global variable. But if it is not available, it will try to get data from file.
-   * Thus, good approach is to remove file storage folder before each test run (and after, for sure).
+   * This method will get data from global variable and/or from from file (previosly saved with put method).
    *
-   * Defining the execution environment is not guaranteed! Is used only as additional check.
-   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
-   * @returns
+   * @param {*} context could be testId or any context (test title, suite, etc) which is used to define testId
+   * @returns array of data (any type), null (if no data found for test) or string (if data type is log)
    */
   getData(context) {
     this.#refreshStorageType();
@@ -100,9 +130,6 @@ class DataStorage {
     let testId = null;
     if (typeof context === 'string') {
       testId = this.#tryToRetrieveTestId(context) || context;
-    } else {
-      // TODO: derive testId from context
-      // testId = context...
     }
 
     if (!testId) {
@@ -110,12 +137,20 @@ class DataStorage {
       return null;
     }
 
-    let testData = '';
+    let testDataFromFile = [];
+    let testDataFromGlobalVar = [];
 
     if (global?.testomatioDataStore) {
-      testData = this.#getDataFromGlobalVar(testId);
+      testDataFromGlobalVar = this.#getDataFromGlobalVar(testId);
       // these frameworks use global variable storage
-      if (testData && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) return testData;
+      // if (testDataFromGlobalVar && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) {
+      if (testDataFromGlobalVar) {
+        // return as string if its log data
+        if (this.dataType === 'log' && testDataFromGlobalVar.length) return testDataFromGlobalVar.join('\n');
+        // return as array for other data types
+        if (testDataFromGlobalVar.length) return testDataFromGlobalVar;
+      }
+      // don't return nothing if no data in global variable
     }
 
     /* condition is removed for mocha
@@ -126,11 +161,16 @@ class DataStorage {
     //   if (testData) return testData;
     // }
 
-    const testDataFromFile = this.#getDataFromFile(testId);
-    testData += testDataFromFile || '';
+    testDataFromFile = this.#getDataFromFile(testId);
 
-    debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
-    return testData || '';
+    if (testDataFromFile.length) {
+      if (this.dataType === 'log') return testDataFromFile.join('\n');
+      return testDataFromFile;
+    }
+    debug(`No "${this.dataType}" data for test id ${testId} in both file and global variable`);
+
+    // in case no data found for test
+    return null;
   }
 
   /**
@@ -166,46 +206,63 @@ class DataStorage {
     this.runningEnvironment = this.getRunningEnviroment();
 
     // some test frameworks do not persist global variables, thus file storage is used for them (by default)
-    if (['playwright', 'codeceptjs'].includes(this.runningEnvironment)) this.isFileStorage = false;
+    if (this.runningEnvironment === 'codeceptjs') this.isFileStorage = false;
+    // playwrigth stores logs by itself; but file storage is used for other data types for playwright
+    if (this.runningEnvironment === 'playwright' && this.dataType === 'log') this.isFileStorage = false;
   }
 
+  /**
+   * @param {*} testId
+   * @returns aray of data (any type)
+   */
   #getDataFromGlobalVar(testId) {
     try {
       if (global?.testomatioDataStore[this.dataType]) {
         const testData = global.testomatioDataStore[this.dataType][testId];
-        debug(`Data for test id ${testId}:\n${testData}`);
-        return testData || '';
+        if (testData) debug(`"${this.dataType}" data for test id ${testId}:`, testData.join(', '));
+        return testData || [];
       }
-      debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
-      return '';
+      // debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
+      return [];
     } catch (e) {
       // there could be no data, ignore
     }
   }
 
+  /**
+   *
+   * @param {*} testId
+   * @returns array of data (any type)
+   */
   #getDataFromFile(testId) {
     try {
       const filepath = join(this.dataDirPath, `${this.dataType}_${testId}`);
       if (fs.existsSync(filepath)) {
-        const testData = fs.readFileSync(filepath, 'utf-8');
-        debug(`Data for test id ${testId}:\n${testData}`);
-        return testData || '';
+        const testDataAsText = fs.readFileSync(filepath, 'utf-8');
+        if (testDataAsText) debug(`"${this.dataType}" data for test id ${testId}:`, testDataAsText);
+        const testDataArr = testDataAsText?.split(os.EOL) || [];
+        return testDataArr;
       }
-      debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
-      return '';
+      // debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
+      return [];
     } catch (e) {
       // there could be no data, ignore
     }
-    return '';
+    return [];
   }
 
+  /**
+   * Puts data to global variable. Unlike the file storage, stores data in array (file storage just append as string).
+   * @param {*} data
+   * @param {*} testId
+   */
   #putDataToGlobalVar(data, testId) {
-    debug('Saving data to global variable for test', testId, ':\n', data, '\n');
+    debug(`Saving data to global variable for test ${testId}:`, data);
     if (!global.testomatioDataStore) global.testomatioDataStore = {};
     if (!global.testomatioDataStore?.[this.dataType]) global.testomatioDataStore[this.dataType] = {};
-    global.testomatioDataStore?.[this.dataType][testId] // eslint-disable-line no-unused-expressions
-      ? (global.testomatioDataStore[this.dataType][testId] += `\n${data}`)
-      : (global.testomatioDataStore[this.dataType][testId] = data);
+
+    if (!global.testomatioDataStore?.[this.dataType][testId]) global.testomatioDataStore[this.dataType][testId] = [];
+    global.testomatioDataStore[this.dataType][testId].push(data);
   }
 
   #putDataToFile(data, testId) {
@@ -215,18 +272,36 @@ class DataStorage {
     if (!fs.existsSync(this.dataDirPath)) fileSystem.createDir(this.dataDirPath);
     debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
 
-    // TODO: handle multiple invocations of JSON.stringify.
-    // UPD: not actual because decided not to use it - it created extra wrapping quotes "" and // (escaped slashes)
-    fs.appendFileSync(filepath, data + os.EOL, 'utf-8');
+    // 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;
+module.exports = DataStorage;
 
 // TODO: consider using fs promises instead of writeSync/appendFileSync to
 // prevent blocking and improve performance (probably queue usage will be required)
 
 // TODO: rewrite client - everything regarding storing artifacts
 // TODO: try to define adapter inside client
-// TODO: use .env
 // TODO: ability to intercept multiple loggers (upd: no need)
+
+/* does not work for Playwright
+    try {
+      const { test } = require('@playwright/test');
+      test.beforeEach(async ({}, testInfo) => {
+        global.testTitle = testInfo.title;
+        global.testomatioRunningEnvironment = 'playwright';
+      });
+    } catch (e) {
+      // ignore
+    }
+// Playwright storage works fine only when running tests from a single file;
+// otherwise it is not possible to define test id/title, it is overwritten
+ TODO: the only way implementation for Pw for now is to pass testInfo inside test
+//  (and process this testInfo inside "put" function)
+*/

package/lib/storages/key-value-storage.js

@@ -0,0 +1,58 @@
+const debug = require('debug')('@testomatio/reporter:key-value-storage');
+const DataStorage = require('./data-storage');
+
+class KeyValueStorage {
+  constructor() {
+    this.dataStorage = new DataStorage('keyvalue');
+
+    // singleton
+    if (!KeyValueStorage.instance) {
+      KeyValueStorage.instance = this;
+    }
+  }
+
+  /**
+   * Stores key-value pair and passes it to reporter
+   * @param {{key: string}} keyValue - key-value pair(s) as object
+   * @param {*} context testId or test title
+   */
+  put(keyValue, context = null) {
+    if (!keyValue) return;
+    this.dataStorage.putData(keyValue, context);
+  }
+
+  #isKeyValueObject(smth) {
+    return smth && typeof smth === 'object' && !Array.isArray(smth) && smth !== null;
+  }
+
+  /**
+   * 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'}
+   */
+  get(context) {
+    if (!context) return null;
+
+    const keyValuesList = this.dataStorage.getData(context);
+    if (!keyValuesList || !keyValuesList?.length) return null;
+
+    const keyValues = {};
+    for (const keyValue of keyValuesList) {
+      if (this.#isKeyValueObject(keyValue)) {
+        Object.assign(keyValues, keyValue);
+      } else if (typeof keyValue === 'string') {
+        try {
+          Object.assign(keyValues, JSON.parse(keyValue));
+        } catch (e) {
+          debug(`Error parsing key-values for test ${context}`, keyValue);
+        }
+      }
+    }
+
+    return Object.keys(keyValues).length ? keyValues : null;
+  }
+}
+
+KeyValueStorage.instance = null;
+
+module.exports = new KeyValueStorage();

package/lib/{logger.js → storages/logger.js}

@@ -1,6 +1,6 @@
 const chalk = require('chalk');
 const debug = require('debug')('@testomatio/reporter:logger');
-const { DataStorage } = require('./dataStorage');
+const DataStorage = require('./data-storage');
 
 const LOG_METHODS = ['assert', 'debug', 'error', 'info', 'log', 'trace', 'warn'];
 const LEVELS = {
@@ -38,20 +38,6 @@ class Logger {
     if (!Logger.instance) {
       Logger.instance = this;
     }
-
-    // add beforeEach hook for mocha. it does not override existing hook, just add new one
-    try {
-      // @ts-ignore
-      if (!beforeEach) return;
-      // @ts-ignore-next-line
-      beforeEach(function () {
-        if (this.currentTest?.__mocha_id__) {
-          global.testTitle = this.currentTest.fullTitle();
-        }
-      });
-    } catch (e) {
-      // ignore
-    }
   }
 
   /**
@@ -61,9 +47,6 @@ class Logger {
    * @param  {...any} values
    */
   step(strings, ...values) {
-    // get testId for mocha
-    const context = global.testTitle ?? null;
-
     let logs = '';
     for (let i = 0; i < strings.length; i++) {
       logs += strings[i];
@@ -72,7 +55,7 @@ class Logger {
       }
     }
     logs = chalk.blue(`> ${logs}`);
-    this.#dataStorage.putData(logs, context);
+    this.#dataStorage.putData(logs);
   }
 
   /**
@@ -117,11 +100,6 @@ class Logger {
   templateLiteralLog(strings, ...args) {
     if (Array.isArray(strings)) strings = strings.filter(item => item !== '').map(item => item.trim());
     if (Array.isArray(args)) args = args.filter(item => item !== '');
-    // entity which is used to define testId
-    let context = null;
-
-    // get testId for mocha
-    context = global.testTitle ?? null;
 
     let logs;
     // this block means tagged template is used (syntax like $`text ${someVar}`)
@@ -146,7 +124,7 @@ class Logger {
       logs = this.#stringifyLogs(strings, ...args);
     }
     this.#originalUserLogger.log(logs);
-    this.#dataStorage.putData(logs, context);
+    this.#dataStorage.putData(logs);
   }
 
   /**
@@ -158,18 +136,12 @@ class Logger {
   #logWrapper(argsArray, level) {
     if (!argsArray.length) return;
 
-    // entity which is used to define testId
-    let context = null;
-
-    // get context for mocha
-    context = global.testTitle ?? null;
-
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
 
     const logs = this.#stringifyLogs(...argsArray);
     const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.#dataStorage.putData(colorizedLogs, context);
+    this.#dataStorage.putData(colorizedLogs);
     try {
       // level.toLowerCase() represents method name (log, warn, error, etc)
       this.#originalUserLogger[level.toLowerCase()](colorizedLogs);
@@ -269,7 +241,6 @@ class Logger {
 
 Logger.instance = null;
 
-// module.exports.Logger = Logger;
 const logger = new Logger();
 
 module.exports = logger;

package/lib/utils/utils.js

@@ -290,6 +290,19 @@ function removeColorCodes(input) {
   return input.replace(/\x1b\[[0-9;]*m/g, '');
 }
 
+const jestHelpers = {
+  getIdOfCurrentlyRunningTest: () => {
+    if (!process.env.JEST_WORKER_ID) return null;
+    try {
+      // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
+      // eslint-disable-next-line no-undef
+      if (expect && expect?.getState()?.currentTestName) return parseTest(expect?.getState()?.currentTestName);
+    } catch (e) {
+      return null;
+    }
+  },
+};
+
 module.exports = {
   isSameTest,
   fetchSourceCode,
@@ -299,6 +312,7 @@ module.exports = {
   fetchFilesFromStackTrace,
   fileSystem,
   getCurrentDateTime,
+  jestHelpers,
   specificTestInfo,
   isValidUrl,
   ansiRegExp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.0.17",
+  "version": "1.0.18-beta.1",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",

package/lib/_ArtifactStorageOld.js

@@ -1,142 +0,0 @@
-const debug = require('debug')('@testomatio/reporter:storage');
-const { join, resolve } = require('path');
-const fs = require('fs');
-const os = require('os');
-const uuid = require('uuid');
-const { TESTOMAT_ARTIFACT_SUFFIX } = require('./constants');
-const { specificTestInfo } = require('./utils/utils');
-
-class ArtifactStorage {
-  
-  constructor(params) {
-    this.isFile = false;
-    this.isMemory = true;
-    this.storage = params?.toFile;
-
-    if (this.storage) {
-      // this is fine to use when you start saving artifacts;
-      // but when you need to retrieve them, you will not know if there is "isFile" param,
-      // because you need to create a new instance of ArtifactStorage inside client
-      // so the solution is make it opposite to isMemory (which will be retrieved from global)
-      this.isFile = true;
-      this.isMemory = false;
-      this.tmpDirFullpath = this.createTestomatTmpDir(ArtifactStorage._tmpPrefix);
-      debug('SAVE to tmp folder mode enabled!');
-    }
-  }
-
-  static async storeToFile(tmpDirName, artifact, testSuffix = "test") {
-    // this assumes to use multiple files for each test. do we really want this?
-    const suffix = TESTOMAT_ARTIFACT_SUFFIX + uuid.v4() + testSuffix;
-    const dirpath = join(os.tmpdir(), tmpDirName);
-    // why json?
-    const filepath = resolve(dirpath, `${suffix}.json`);
-
-    return fs.promises.appendFile(filepath, JSON.stringify(artifact));
-  }
-
-  static async artifact(artifact, context) {
-    // TODO: mode for different pre-hooks. As variant - "all-tests" || "only_fail"
-    // const mode = process.env.TESTOMAT_ARTIFACTS || "only_fail";
-
-    // you save the artifact without specifying its source - test id
-    if (Array.isArray(global.testomatioArtifacts)) {
-      debug("Saving artifacts to global storage");
-
-      global.testomatioArtifacts.push(artifact);
-    }
-
-    if (global?.testomatioArtifacts === undefined) {
-      const tmpDirNames = ArtifactStorage.tmpTestomatDirNames();
-
-      const testSuffix = specificTestInfo(context.test);
-
-      if (Array.isArray(tmpDirNames) && tmpDirNames.length) {
-        debug("Saving artifacts to memory tmp folder");
-
-        return ArtifactStorage.storeToFile(tmpDirNames[tmpDirNames.length - 1], artifact, testSuffix);
-      }
-    }
-  }
-
-  async artifactByTestName(test) {
-    const list = [];
-
-    if (this.isFile && this.tmpDirFullpath) {
-      const files = fs.readdirSync(this.tmpDirFullpath);
-
-      for (const file of files) {
-        if (file.includes(test)) {
-          const buff = await fs.promises.readFile(`${this.tmpDirFullpath  }/${  file}`);
-
-          list.push(JSON.parse(buff.toString()));
-        }
-      }
-    }
-
-    return list;
-  }
-
-  // returns all the content from all files; do we really need it?
-  async tmpContents() {
-    const contents = [];
-
-    if (this.isFile && this.tmpDirFullpath) {
-      const files = fs.readdirSync(this.tmpDirFullpath);
-
-      for (const file of files) {
-        const buff = await fs.promises.readFile(`${this.tmpDirFullpath  }/${  file}`);
-        const content = buff.toString();
-
-        contents.push(content);
-      }
-    }
-
-    return contents;
-  }
-
-  createTestomatTmpDir(clientPrefix) {
-    return fs.mkdtempSync(join(os.tmpdir(), clientPrefix));
-  }
-
-  clearTmpDirByName(name) {
-    const tmpDirPath = join(os.tmpdir(), name);
-
-    if (fs.existsSync(tmpDirPath)) {
-      fs.rmSync(tmpDirPath, { recursive: true });
-      debug(` Testomat tmpDir = ${tmpDirPath} was deleted successfully!`);
-
-      
-    }
-  }
-
-  // no need to use multiple dirs; we can implement it later if required
-  static tmpTestomatDirNames() {
-    const subname = ArtifactStorage._tmpPrefix || "tsmt_reporter";
-
-    return fs.readdirSync(os.tmpdir(), { withFileTypes: true })
-      .filter((item) => item.isDirectory())
-      .map((item) => item.name)
-      .filter((name) => name.includes(subname));
-  }
-
-  cleanup() {
-    // when you do a cleanup, I know nothing about isFile param
-    if (this.isFile && this.tmpDirFullpath) {
-      const tmpDirNames = ArtifactStorage.tmpTestomatDirNames();
-
-      if (Array.isArray(tmpDirNames) && tmpDirNames.length) {
-        for (const name of tmpDirNames) {
-          this.clearTmpDirByName(name);
-        }
-      }
-    }
-    else {
-      debug("The tmp folder has not been created! Nothing to delete");
-    }
-  }
-}
-
-ArtifactStorage._tmpPrefix = "tsmt_reporter";
-
-module.exports = ArtifactStorage;

package/lib/artifactStorage.js

@@ -1,25 +0,0 @@
-// const debug = require('debug')('@testomatio/reporter:logger');
-const { DataStorage } = require('./dataStorage');
-
-class ArtifactStorage {
-  constructor() {
-    this.dataStorage = new DataStorage('artifact');
-
-    // singleton
-    if (!ArtifactStorage.instance) {
-      ArtifactStorage.instance = this;
-    }
-  }
-
-  save(data, context = null) {
-    this.dataStorage.putData(data, context);
-  }
-
-  get(context) {
-    this.dataStorage.getData(context);
-  }
-}
-
-ArtifactStorage.instance = null;
-
-module.exports = new ArtifactStorage();