@testomatio/reporter 1.2.2-beta → 1.2.3-beta

package/lib/adapter/codecept.js

@@ -1,9 +1,9 @@
 const debug = require('debug')('@testomatio/reporter:adapter:codeceptjs');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
-const { STATUS, APP_PREFIX } = require('../constants');
+const { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE } = require('../constants');
 const upload = require('../fileUploader');
-const Output = require('../output');
+const { parseTest: getIdFromTestTitle, fileSystem } = require('../util');
 
 if (!global.codeceptjs) {
   // eslint-disable-next-line global-require, import/no-extraneous-dependencies
@@ -16,9 +16,9 @@ let currentMetaStep = [];
 let error;
 let stepShift = 0;
 
-const output = new Output({
-  filterFn: stack => !stack.includes('codeceptjs/lib/output'), // output from codeceptjs
-});
+// const output = new Output({
+//   filterFn: stack => !stack.includes('codeceptjs/lib/output'), // output from codeceptjs
+// });
 
 let stepStart = new Date();
 
@@ -51,24 +51,34 @@ function CodeceptReporter(config) {
 
   recorder.startUnlessRunning();
 
+  global.testomatioRunningEnvironment = 'codeceptjs';
+
   // Listening to events
   event.dispatcher.on(event.all.before, () => {
+    // clear tmp dir
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+
     recorder.add('Creating new run', () => client.createRun());
     videos = [];
     traces = [];
+
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
   });
 
   event.dispatcher.on(event.test.before, () => {
     recorder.add(() => {
       currentMetaStep = [];
-      output.reset();
-      output.start();
+      // output.reset();
+      // output.start();
       stepShift = 0;
     });
+
+    global.testomatioDataStore.steps = [];
   });
 
   event.dispatcher.on(event.test.started, test => {
     testTimeMap[test.id] = Date.now();
+    if (global.testomatioDataStore) global.testomatioDataStore.currentlyRunningTestId = getIdFromTestTitle(test.title);
   });
 
   event.dispatcher.on(event.all.result, async () => {
@@ -97,10 +107,10 @@ function CodeceptReporter(config) {
       suite_title: test.parent && test.parent.title,
       message: testObj.message,
       time: getDuration(test),
-      steps: output.text(),
+      steps: global.testomatioDataStore.steps.join('\n') || null,
       test_id: testId,
     });
-    output.stop();
+    // output.stop();
   });
 
   event.dispatcher.on(event.test.failed, (test, err) => {
@@ -125,7 +135,7 @@ function CodeceptReporter(config) {
         time: 0,
       });
     }
-    output.stop();
+    // output.stop();
   });
 
   event.dispatcher.on(event.test.after, test => {
@@ -141,32 +151,33 @@ function CodeceptReporter(config) {
 
     const files = [];
     if (artifacts.screenshot) files.push({ path: artifacts.screenshot, type: 'image/png' });
-    // todo: video must be uploaded later....    
+    // todo: video must be uploaded later....
 
-    
-    const reportTestPromise = client.addTestRun(STATUS.FAILED, {
-      ...stripExampleFromTitle(title),
-      test_id: testId,
-      suite_title: test.parent && test.parent.title,
-      error,
-      message: testObj.message,
-      time: getDuration(test),
-      files,
-      steps: output.text(),
-    }).then(pipes => {
-      testId = pipes.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
-
-      debug("artifacts", artifacts);
-      
-      for (const aid in artifacts) {
-        if (aid.startsWith('video')) videos.push({ testId, title, path: artifacts[aid], type: 'video/webm' });
-        if (aid.startsWith('trace')) traces.push({ testId, title, path: artifacts[aid], type: 'application/zip' });
-      }
-    });
+    const reportTestPromise = client
+      .addTestRun(STATUS.FAILED, {
+        ...stripExampleFromTitle(title),
+        test_id: testId,
+        suite_title: test.parent && test.parent.title,
+        error,
+        message: testObj.message,
+        time: getDuration(test),
+        files,
+        steps: global.testomatioDataStore.steps.join('\n') || null,
+      })
+      .then(pipes => {
+        testId = pipes.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
+
+        debug('artifacts', artifacts);
+
+        for (const aid in artifacts) {
+          if (aid.startsWith('video')) videos.push({ testId, title, path: artifacts[aid], type: 'video/webm' });
+          if (aid.startsWith('trace')) traces.push({ testId, title, path: artifacts[aid], type: 'application/zip' });
+        }
+      });
 
     reportTestPromises.push(reportTestPromise);
 
-    output.stop();
+    // output.stop();
   });
 
   event.dispatcher.on(event.test.skipped, test => {
@@ -182,7 +193,7 @@ function CodeceptReporter(config) {
       message: testObj.message,
       time: getDuration(test),
     });
-    output.stop();
+    // output.stop();
   });
 
   event.dispatcher.on(event.step.started, step => {
@@ -207,30 +218,37 @@ function CodeceptReporter(config) {
         // eslint-disable-next-line no-continue
         if (!metaSteps[i]) continue;
         if (metaSteps[i].isBDD()) {
-          output.push(repeat(stepShift) + chalk.bold(metaSteps[i].toString()) + metaSteps[i].comment);
+          // output.push(repeat(stepShift) + chalk.bold(metaSteps[i].toString()) + metaSteps[i].comment);
+          global.testomatioDataStore.steps.push(
+            repeat(stepShift) + chalk.bold(metaSteps[i].toString()) + metaSteps[i].comment,
+          );
         } else {
-          output.push(repeat(stepShift) + chalk.green.bold(metaSteps[i].toString()));
+          // output.push(repeat(stepShift) + chalk.green.bold(metaSteps[i].toString()));
+          global.testomatioDataStore.steps.push(repeat(stepShift) + chalk.green.bold(metaSteps[i].toString()));
         }
       }
     }
     currentMetaStep = metaSteps;
     stepShift = 2 * shift;
 
-    const durationMs = (+new Date() - (+stepStart));
+    const durationMs = +new Date() - (+stepStart);
     let duration = '';
     if (durationMs) {
       duration = repeat(1) + chalk.grey(`(${durationMs}ms)`);
     }
 
     if (step.status === STATUS.FAILED) {
-      output.push(repeat(stepShift) + chalk.red(step.toString()) + duration);
+      // output.push(repeat(stepShift) + chalk.red(step.toString()) + duration);
+      global.testomatioDataStore.steps.push(repeat(stepShift) + chalk.red(step.toString()) + duration);
     } else {
-      output.push(repeat(stepShift) + step.toString() + duration);
+      // output.push(repeat(stepShift) + step.toString() + duration);
+      global.testomatioDataStore.steps.push(repeat(stepShift) + step.toString() + duration);
     }
   });
 
   event.dispatcher.on(event.step.comment, step => {
-    output.push(chalk.cyan.bold(step.toString()));
+    // output.push(chalk.cyan.bold(step.toString()));
+    global.testomatioDataStore.steps.push(chalk.cyan.bold(step.toString()));
   });
 }
 

package/lib/adapter/cucumber/current.js

@@ -1,35 +1,59 @@
 // eslint-disable-next-line global-require, import/no-extraneous-dependencies
-const { Formatter, formatterHelpers } = require("@cucumber/cucumber");
+const { Formatter, formatterHelpers } = require('@cucumber/cucumber');
 const chalk = require('chalk');
 const fs = require('fs');
-const { STATUS } = require('../../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
 const TestomatClient = require('../../client');
+const logger = require('../../logger');
+const { parseTest, fileSystem } = require('../../util');
+
+const { GherkinDocumentParser, PickleParser } = formatterHelpers;
+const { getGherkinScenarioLocationMap, getGherkinStepMap } = GherkinDocumentParser;
+const { getPickleStepMap } = PickleParser;
+
+function getTestId(scenario) {
+  if (scenario) {
+    for (const tag of scenario.tags) {
+      const testId = parseTest(tag.name);
+      if (testId) return testId;
+    }
+  }
 
-const { GherkinDocumentParser, PickleParser } = formatterHelpers
-const {
-  getGherkinScenarioLocationMap,
-  getGherkinStepMap,
-} = GherkinDocumentParser
-const { getPickleStepMap } = PickleParser
+  return null;
+}
 
 class CucumberReporter extends Formatter {
   constructor(options) {
     super(options);
-    options.eventBroadcaster.on('envelope', this.parseEnvelope.bind(this))
+    options.eventBroadcaster.on('envelope', this.parseEnvelope.bind(this));
     this.failures = [];
     this.cases = [];
 
     this.client = new TestomatClient();
     this.status = STATUS.PASSED;
 
+    global.testomatioRunningEnvironment = 'cucumber:current';
   }
 
   parseEnvelope(envelope) {
-    if (envelope.testCaseStarted && this.client) this.client.createRun()
+    if (envelope.testRunStarted) {
+      fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+    }
+    if (envelope.testCaseStarted && this.client) {
+      this.client.createRun();
+      this.onTestCaseStarted(envelope.testCaseStarted);
+    }
     if (envelope.testCaseFinished) this.onTestCaseFinished(envelope.testCaseFinished);
     if (envelope.testRunFinished) this.onTestRunFinished(envelope);
   }
 
+  onTestCaseStarted(testCaseStarted) {
+    const testCaseAttempt = this.eventDataCollector.getTestCaseAttempt(testCaseStarted.id);
+    const testId = getTestId(testCaseAttempt.pickle);
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+    global.testomatioDataStore.currentlyRunningTestId = testId;
+  }
+
   onTestCaseFinished(testCaseFinished) {
     const testCaseAttempt = this.eventDataCollector.getTestCaseAttempt(testCaseFinished.testCaseStartedId);
 
@@ -64,10 +88,12 @@ class CucumberReporter extends Formatter {
     }
 
     const scenario = testCaseAttempt.pickle.name;
-    const testId = testCaseAttempt.pickle.id;
+    // this may broke something (it is supposed to work, but I am sure it did not)
+    // const testId = testCaseAttempt.pickle.id;
+    const testId = getTestId(testCaseAttempt.pickle);
 
     let exampleString = '';
-    if (example) exampleString = ` ${example.join(' | ')}`
+    if (example) exampleString = ` ${example.join(' | ')}`;
     let cliMessage = `${chalk.bold(scenario)}${exampleString}: ${chalk[color].bold(status.toUpperCase())} `;
 
     if (message) cliMessage += chalk.gray(message.split('\n')[0]);
@@ -79,15 +105,21 @@ class CucumberReporter extends Formatter {
 
     const time = Object.values(testCaseAttempt.stepResults)
       .map(t => t.duration)
-      .reduce((sum, duration) => sum + (duration.seconds * 1000)  + (duration.nanos / 1000000), 0)
+      .reduce((sum, duration) => sum + duration.seconds * 1000 + duration.nanos / 1000000, 0);
 
     if (!this.client) return;
 
+    const logs = logger.getLogs(testId);
+
     this.client.addTestRun(status, {
       // error: testCaseAttempt.worstTestStepResult.message,
       message,
-      steps: getSteps(testCaseAttempt).map(s => s.toString()).join('\n').trim(),
-      example: { ...example},
+      steps: getSteps(testCaseAttempt)
+        .map(s => s.toString())
+        .join('\n')
+        .trim(),
+      example: { ...example },
+      stack: logs,
       title: scenario,
       test_id: testId,
       time,
@@ -99,21 +131,20 @@ class CucumberReporter extends Formatter {
       console.log(chalk.bold('\nSUMMARY:\n\n'));
 
       this.failures.forEach((tc, i) => {
-        let message = `  ${i+1}) ${tc.pickle.name}\n`;
+        let message = `  ${i + 1}) ${tc.pickle.name}\n`;
 
         const steps = getSteps(tc);
 
         steps.forEach(s => {
-          message += `     ${s.toString()}\n`
-        })
+          message += `     ${s.toString()}\n`;
+        });
 
         console.log(message);
         if (tc?.worstTestStepResult?.message) {
           console.log(chalk.red(tc?.worstTestStepResult?.message));
         }
         console.log();
-
-      })
+      });
     }
 
     const { testRunFinished } = envelope;
@@ -125,46 +156,48 @@ class CucumberReporter extends Formatter {
 
     if (!this.client) return;
 
-    this.client.updateRunStatus(testRunFinished.success ? STATUS.PASSED : STATUS.FAILED)
+    this.client.updateRunStatus(testRunFinished.success ? STATUS.PASSED : STATUS.FAILED);
   }
 }
 
 function getSteps(tc) {
   const stepIds = Object.keys(tc.stepResults);
-  const pickleSteps = getPickleStepMap(tc.pickle)
-  return stepIds.map(stepId => {
-    const ts = tc.testCase.testSteps.find(t => t.id === stepId);
-    if (!ts) return;
-    if (!ts.pickleStepId) return;
-    const result = tc.stepResults[stepId];
-    const pickleStep = pickleSteps[ts.pickleStepId];
-    const sourceStepId = pickleStep.astNodeIds[0];
-    const step = {
-      text: pickleStep.text,
-      duration: result.duration,
-      status: result.status,
-    }
-    const color = getStatusColor(result.status);
-    if (sourceStepId && getGherkinStepMap(tc.gherkinDocument)[sourceStepId]) {
-      step.keyword = getGherkinStepMap(tc.gherkinDocument)[sourceStepId].keyword;
-    }
-    step.toString = function toString() {
-      const duration = step.duration.seconds * 1000 + (step.duration.nanos / 1000000)
-      const durationString = ` ${  chalk.gray(`(${Number(duration).toFixed(2)}ms)`)}`;
-      const stepString = `${chalk.bold(this.keyword)}${this.text}`.trim();
-      if (color === 'red') return chalk.red(stepString) + durationString;
-      if (color === 'yellow') return chalk.yellow(stepString) + durationString;
-      return stepString + durationString;
-    }
-    return step;
-  }).filter(s => !!s)
+  const pickleSteps = getPickleStepMap(tc.pickle);
+  return stepIds
+    .map(stepId => {
+      const ts = tc.testCase.testSteps.find(t => t.id === stepId);
+      if (!ts) return;
+      if (!ts.pickleStepId) return;
+      const result = tc.stepResults[stepId];
+      const pickleStep = pickleSteps[ts.pickleStepId];
+      const sourceStepId = pickleStep.astNodeIds[0];
+      const step = {
+        text: pickleStep.text,
+        duration: result.duration,
+        status: result.status,
+      };
+      const color = getStatusColor(result.status);
+      if (sourceStepId && getGherkinStepMap(tc.gherkinDocument)[sourceStepId]) {
+        step.keyword = getGherkinStepMap(tc.gherkinDocument)[sourceStepId].keyword;
+      }
+      step.toString = function toString() {
+        const duration = step.duration.seconds * 1000 + step.duration.nanos / 1000000;
+        const durationString = ` ${chalk.gray(`(${Number(duration).toFixed(2)}ms)`)}`;
+        const stepString = `${chalk.bold(this.keyword)}${this.text}`.trim();
+        if (color === 'red') return chalk.red(stepString) + durationString;
+        if (color === 'yellow') return chalk.yellow(stepString) + durationString;
+        return stepString + durationString;
+      };
+      return step;
+    })
+    .filter(s => !!s);
 }
 
 function getStatusColor(status) {
   if (status === 'UNDEFINED') return 'yellow';
   if (status === 'SKIPPED') return 'yellow';
   if (status === 'FAILED') return 'red';
-  return 'green'
+  return 'green';
 }
 
 function getExample(testCaseAttempt) {
@@ -173,11 +206,14 @@ function getExample(testCaseAttempt) {
   if (!nodesMap[exampleNodeId]) return;
   const featureDoc = fs.readFileSync(testCaseAttempt.gherkinDocument.uri).toString();
   const { line } = nodesMap[exampleNodeId];
-  const example = featureDoc.split('\n')[line-1];
+  const example = featureDoc.split('\n')[line - 1];
   if (example) {
-    return example.trim().split('|').filter(r => !!r).map(r => r.trim());
-  };
-
+    return example
+      .trim()
+      .split('|')
+      .filter(r => !!r)
+      .map(r => r.trim());
+  }
 }
 
 module.exports = CucumberReporter;

package/lib/adapter/cucumber/legacy.js

@@ -1,8 +1,8 @@
 // eslint-disable-next-line global-require, import/no-extraneous-dependencies, import/no-unresolved
 const { Formatter } = require('cucumber');
 const chalk = require('chalk');
-const { parseTest } = require('../../util');
-const { STATUS } = require('../../constants');
+const { parseTest, fileSystem } = require('../../util');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
 const TestomatClient = require('../../client');
 
 const createTestomatFormatter = apiKey => {
@@ -96,9 +96,23 @@ const createTestomatFormatter = apiKey => {
       this.status = STATUS.PASSED.toString();
 
       options.eventBroadcaster.on('gherkin-document', addDocument);
-      options.eventBroadcaster.on('test-run-started', () => this?.client?.createRun());
+      options.eventBroadcaster.on('test-run-started', () => {
+        fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+        this?.client?.createRun();
+      });
       options.eventBroadcaster.on('test-case-finished', this.onTestCaseFinished.bind(this));
+      options.eventBroadcaster.on('test-case-started', this.onTestCaseStarted.bind(this));
       options.eventBroadcaster.on('test-run-finished', () => this?.client?.updateRunStatus(this.status));
+
+      global.testomatioRunningEnvironment = 'cucumber:legacy';
+    }
+
+    onTestCaseStarted(event) {
+      const scenario = getScenario(event.sourceLocation);
+      const testId = getTestId(scenario);
+      
+      if (!global.testomatioDataStore) global.testomatioDataStore = {};
+      global.testomatioDataStore.currentlyRunningTestId = testId;
     }
 
     onTestCaseFinished(event) {

package/lib/adapter/jest.js

@@ -13,8 +13,13 @@ class JestReporter {
 
   static getIdOfCurrentlyRunningTest() {
     if (!process.env.JEST_WORKER_ID) return null;
-    // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
-    return parseTest(expect?.getState()?.currentTestName) || null; // eslint-disable-line
+    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() {

package/lib/adapter/playwright.js

@@ -3,10 +3,11 @@ const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
-const { APP_PREFIX, STATUS: Status } = require('../constants');
+const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE } = require('../constants');
 const TestomatioClient = require('../client');
 const { isArtifactsEnabled } = require('../fileUploader');
-const { parseTest } = require('../util');
+const { parseTest, fileSystem } = require('../util');
+const { setCurrentlyRunningTestId } = require('../helpers');
 
 const reportTestPromises = [];
 
@@ -21,9 +22,21 @@ class TestomatioReporter {
     if (!this.client) return;
     this.suite = suite;
     this.client.createRun();
+
+    // for data storage
+    // fileSystem.createDir(TESTOMAT_TMP_STORAGE.mainDir);
+  }
+
+  onTestBegin(test, result) {
+    const testId = parseTest(test.title);
+    setCurrentlyRunningTestId(testId);
+    // global.testomatioDataStore.currentlyRunningTestId = testId;
+    // TestomatioReporter.currentlyRunningTestId = testId;
   }
 
   onTestEnd(test, result) {
+    // reset currently running test id
+    // setCurrentlyRunningTestId('');
     if (!this.client) return;
 
     let testId = parseTest(test.title);
@@ -37,21 +50,26 @@ class TestomatioReporter {
     for (const step of result.steps) {
       appendStep(step, steps);
     }
-    
-    const reportTestPromise = this.client.addTestRun(checkStatus(result.status), {
-      error,
-      test_id: testId,
-      suite_title,
-      title,
-      steps: steps.join('\n'),
-      time: duration,
-    }).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)
+
+    const reportTestPromise = this.client
+      .addTestRun(checkStatus(result.status), {
+        error,
+        test_id: testId,
+        suite_title,
+        title,
+        steps: steps.join('\n'),
+        time: duration,
       })
-    });;
+      .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),
+        });
+      });
 
     reportTestPromises.push(reportTestPromise);
   }
@@ -67,10 +85,9 @@ class TestomatioReporter {
       const promises = [];
 
       for (const upload of this.uploads) {
-
         const { title, testId, suite_title } = upload;
 
-        const files = upload.files.map((attachment) => {
+        const files = upload.files.map(attachment => {
           if (attachment.body) {
             const fileName = tmpFile();
             fs.writeFileSync(fileName, attachment.body);
@@ -78,7 +95,6 @@ class TestomatioReporter {
           return { path: attachment.path, title, type: attachment.contentType };
         });
 
-
         promises.push(
           this.client.addTestRun(undefined, {
             test_id: testId,

package/lib/client.js

@@ -7,7 +7,6 @@ const { randomUUID } = require('crypto');
 const upload = require('./fileUploader');
 const { APP_PREFIX } = require('./constants');
 const pipesFactory = require('./pipe');
-const logger = require('./logger');
 
 /**
  * @typedef {import('../types').TestData} TestData
@@ -48,13 +47,13 @@ class Client {
     };
 
     global.testomatioArtifacts = [];
-    // TODO: create global storage
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
 
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun(runParams))))
       .catch(err => console.log(APP_PREFIX, err))
       .then(() => undefined); // fixes return type
-    debug('Run', this.queue);
+    // debug('Run', this.queue);
     return this.queue;
   }
 
@@ -93,20 +92,22 @@ class Client {
 
     const uploadedFiles = [];
 
-    let stack = '';
+    let stack = testData.stack || '';
 
     if (error) {
       stack = this.formatError(error) || '';
       message = error?.message;
     }
     if (steps) {
-      stack = this.formatSteps(stack, steps);
+      stack += this.formatSteps(stack, steps);
     }
 
+    // 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 testLogs = logger.getLogs(test_id);
-    debug(`Test logs for ${test_id}:\n`, testLogs);
+    // debug(`Test logs for ${test_id}:\n`, testLogs);
     if (stack) stack += '\n\n';
-    stack += testLogs;
+    stack += testLogs ? `${chalk.bold('Logs:')}\n${testLogs}` : '';
 
     if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
       debug('CLIENT storeArtifact', storeArtifacts);

package/lib/dataStorage.js

@@ -6,21 +6,41 @@ const { join } = require('path');
 const JestReporter = require('./adapter/jest');
 const { TESTOMAT_TMP_STORAGE } = require('./constants');
 const { fileSystem } = require('./util');
-
+// const { getCurrentlyRunningTestId } = require('./helpers');
 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.
    * dataType: 'log' | 'artifact' | ...
    * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
-   * @param {*} params
    */
-  constructor(dataType, params = {}) {
-    if (!dataType) throw new Error('Data type is required when creating data storage');
+  constructor(dataType) {
+    // if (!dataType) throw new Error('Data type is required when creating data storage');
     this.dataType = dataType || 'data';
-    this.dataDirName = `${dataType}s`;
-    this.isFileStorage = params?.isFileStorage ?? !global.testomatioDataStore;
+    this.dataDirName = this.dataType;
+
+    this._refreshStorageType();
+
+    // dir is created in any case (not to recheck its existence every time)
+    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataDirName);
+    fileSystem.createDir(this.dataDirPath);
+
+    debug(`Data storage mode: ${this.isFileStorage ? 'file' : 'memory'}`);
+  }
+
+  // TODO: implement
+  // eslint-disable-next-line no-unused-vars
+  getTestIdFromContext(context) {
+    // return testId;
+  }
 
+  /**
+   * Refreshes storage type (file or global variable) depending on current environment
+   * This method should be run on each attempt to put or get data from/to storage
+   * Because storage instance is created before the test runner is started
+   */
+  _refreshStorageType() {
+    this.isFileStorage = !global.testomatioDataStore;
     /*
       FYI:
       If this storage instance is used within test runner, it works fine.
@@ -30,20 +50,10 @@ class DataStorage {
       and potentially useless when get data from storage
     */
     this.runningEnvironment = this.getRunningEnviroment();
-    if (this.runningEnvironment === 'jest') this.isFileStorage = true;
-
-    if (this.isFileStorage) {
-      this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataDirName);
-      fileSystem.createDir(this.dataDirPath);
-    }
 
-    debug(`Data storage mode: ${this.isFileStorage ? 'file' : 'memory'}`);
-  }
-
-  // TODO: implement
-  getTestIdFromContext(context) { // eslint-disable-line
-    // eslint-disable-line
-    // return testId;
+    // jest does not persist global variables, thus file storage is used
+    if (this.runningEnvironment === 'jest') this.isFileStorage = true;
+    if (this.runningEnvironment === 'playwright') this.isFileStorage = true;
   }
 
   /**
@@ -51,14 +61,28 @@ class DataStorage {
    * @returns jest | mocha | ...
    */
   getRunningEnviroment() {
+    // jest
     if (process.env.JEST_WORKER_ID) return 'jest';
+
+    // mocha
     try {
       // @ts-expect-error mocha is defined only in mocha environment
       if (typeof mocha !== 'undefined') return 'mocha';
     } catch (e) {
       // ignore
     }
-    return undefined;
+
+    // codeceptjs
+    // @ts-expect-error codeceptjs is defined only in codeceptjs environment
+    if (global.codeceptjs) return 'codeceptjs';
+
+    // others
+    // 'cucumber:current', 'cucumber:legacy'
+    if (global.testomatioRunningEnvironment) return global.testomatioRunningEnvironment;
+
+    if (process.env.PLAYWRIGHT_TEST_BASE_URL) return 'playwright';
+
+    return null;
   }
 
   /**
@@ -68,7 +92,7 @@ class DataStorage {
    * @returns
    */
   putData(data, context = null) {
-    // this.isFileStorage = !global.testomatioDataStore;
+    this._refreshStorageType();
 
     let testId = null;
     if (typeof context === 'string') {
@@ -80,9 +104,17 @@ class DataStorage {
 
     // try to get testId for Jest
     if (this.runningEnvironment === 'jest') testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
+    if (this.runningEnvironment === 'codeceptjs') testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
+    // if (this.runningEnvironment === 'playwright') testId = testId ?? getCurrentlyRunningTestId();
+    // get id from global store
+    if (global.testomatioDataStore && global.testomatioDataStore.currentlyRunningTestId)
+      testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
 
     // if testId is not provided, data is be saved to `{dataType}_other` file;
-    if (!testId) testId = 'other';
+    if (!testId) {
+      debug(`No test id provided for ${this.dataType} data: ${data}`);
+      return;
+    }
 
     if (this.isFileStorage) {
       this._putDataToFile(data, testId);
@@ -92,13 +124,17 @@ class DataStorage {
   }
 
   /**
-   * Returns data, stored for specific testId (or data which was stored without test id specified)
+   * 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).
    *
-   * (Don't try to guess the execution environment (e.g. test runner) inside this method, it could be any)
+   * 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
    */
   getData(context) {
+    this._refreshStorageType();
+
     let testId = null;
     if (typeof context === 'string') {
       testId = context;
@@ -109,16 +145,23 @@ class DataStorage {
 
     if (!testId) {
       debug(`Cannot get test id from passed context:\n}`, context);
+      return null;
     }
 
-    if (this.isFileStorage) {
-      return this._getDataFromFile(testId);
-    }
+    let testData = null;
+
     if (global?.testomatioDataStore) {
-      return this._getDataFromGlobalVar(testId);
+      testData = this._getDataFromGlobalVar(testId);
+      if (testData) return testData;
     }
+
+    if (this.isFileStorage || !testData) {
+      testData = this._getDataFromFile(testId);
+      if (testData) return testData;
+    }
+
     debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
-    return null;
+    return testData;
   }
 
   _getDataFromGlobalVar(testId) {
@@ -128,7 +171,7 @@ class DataStorage {
         debug(`Data for test id ${testId}:\n${testData}`);
         return testData;
       }
-      debug(`No ${this.dataType} data for test id ${testId}`);
+      debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
       return null;
     } catch (e) {
       // there could be no data, ignore
@@ -137,13 +180,13 @@ class DataStorage {
 
   _getDataFromFile(testId) {
     try {
-      const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, `${this.dataType}_${testId}`);
+      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;
       }
-      debug(`No ${this.dataType} data for test id ${testId}`);
+      debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
       return null;
     } catch (e) {
       // there could be no data, ignore
@@ -153,14 +196,16 @@ class DataStorage {
 
   _putDataToGlobalVar(data, testId) {
     debug('Saving data to global variable for test', testId, ':\n', data, '\n');
-    global.testomatioDataStore[this.dataDirName] = {};
-    global.testomatioDataStore[this.dataDirName][testId] = data;
+    if (!global.testomatioDataStore[this.dataDirName]) global.testomatioDataStore[this.dataDirName] = {};
+    global.testomatioDataStore[this.dataDirName][testId] // eslint-disable-line no-unused-expressions
+      ? (global.testomatioDataStore[this.dataDirName][testId] += `\n${data}`)
+      : (global.testomatioDataStore[this.dataDirName][testId] = data);
   }
 
   _putDataToFile(data, testId) {
     if (typeof data !== 'string') data = JSON.stringify(data);
     const filename = `${this.dataType}_${testId}`;
-    const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, filename);
+    const filepath = join(this.dataDirPath, filename);
     debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
 
     // TODO: handle multiple invocations of JSON.stringify.
@@ -177,4 +222,20 @@ module.exports.DataStorage = DataStorage;
 // TODO: rewrite client - everything regarding storing artifacts
 // TODO: try to define adapter inside client
 // TODO: use .env
-// TODO: ability to intercept multiple loggers
+// TODO: ability to intercept multiple loggers (upd: no need)
+
+/* Playwright
+There is no global scope sharing between tests and reporter listeners.
+Thus need to use file storage. But when tests are run in parallel, the new problem occurs.
+Tried to solve it by using the TEST_WORKER_INDEX env variable, but it is available inside the listener
+(available only inside the test). Thus when cannot match currently running test id from the reporter listener
+with the currently running test.
+The only solution I see for now is to pass the test id to the logger from the test itself.
+By passing the testInfo param to the test function:
+async ({ page }, testInfo)
+and then retrieving the .title from it.
+*/
+
+/* Cypress
+Parallelization is only available if using Cypress Dashboard??
+*/

package/lib/helpers.js

@@ -0,0 +1,34 @@
+const path = require('path');
+const fs = require('fs');
+const { TESTOMAT_TMP_STORAGE } = require('./constants');
+
+// NEXT HELPERS ARE CREATED FOR PLAYWRIGHT. IGNORE FOR NOW. PROBABLY WILL BE REMOVED SHORTLY
+
+// TEST_WORKER_INDEX is not available inside the test listener :/
+/**
+ * Sets id of currently running test to storage (global variable or file)
+ * Used for Playwright
+ * @param {*} testId
+ */
+function setCurrentlyRunningTestIdForPlaywright(testId) {
+  const workerId = +process.env.TEST_WORKER_INDEX || 0;
+  const filePath = path.join(TESTOMAT_TMP_STORAGE.mainDir,  'current_test_id_' + workerId);
+  fs.writeFileSync(filePath, testId);
+}
+
+/**
+ * Gets id of currently running test from storage (global variable or file)
+ * Used for Playwright
+ * @returns string test id of currently running test
+ */
+function getCurrentlyRunningTestIdForPlaywright() {
+  const workerId = +process.env.TEST_WORKER_INDEX || 0;
+  const filePath = path.join(TESTOMAT_TMP_STORAGE.mainDir, 'current_test_id_' + workerId);
+  if (fs.existsSync(filePath)) {
+    return fs.readFileSync(filePath, 'utf8') || null;
+  }
+  return null;
+};
+
+module.exports.setCurrentlyRunningTestId = setCurrentlyRunningTestIdForPlaywright;
+module.exports.getCurrentlyRunningTestId = getCurrentlyRunningTestIdForPlaywright;

package/lib/logger.js

@@ -24,11 +24,11 @@ class Logger {
   // _originalUserLogger used to output logs to console by the user logger
   // _loggerToIntercept intercepted and reassigned immediately when added
 
-  constructor(params = {}) {
+  constructor() {
     // set default logger to be used in log, warn, error, etc methods
     this._originalUserLogger = { ...console };
 
-    this.dataStorage = new DataStorage('log', params);
+    this.dataStorage = new DataStorage('log');
     this.logLevel = process?.env?.LOG_LEVEL?.toUpperCase() || 'ALL';
 
     // commented because prefer to use "intercept" method
@@ -77,8 +77,8 @@ class Logger {
   /**
    * Allows you to define a step inside a test. Step name is attached to the report and
    * helps to understand the test flow.
-   * @param {*} strings 
-   * @param  {...any} values 
+   * @param {*} strings
+   * @param  {...any} values
    */
   step(strings, ...values) {
     let logs = '';
@@ -98,7 +98,8 @@ class Logger {
    * @returns
    */
   getLogs(context) {
-    return this.dataStorage.getData(context);
+    const logs = this.dataStorage.getData(context);
+    return logs || '';
   }
 
   _strinfifyLogs(...args) {
@@ -121,6 +122,9 @@ class Logger {
   }
 
   assert(...args) {
+    // sometimes user invokes logger without any arguments passed
+    if (!args.length) return;
+
     const level = 'ERROR';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -135,6 +139,8 @@ class Logger {
   }
 
   debug(...args) {
+    if (!args.length) return;
+
     const level = 'DEBUG';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -151,6 +157,8 @@ class Logger {
   }
 
   error(...args) {
+    if (!args.length) return;
+
     const level = 'ERROR';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -166,6 +174,8 @@ class Logger {
   }
 
   info(...args) {
+    if (!args.length) return;
+
     const level = 'INFO';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -180,6 +190,8 @@ class Logger {
   }
 
   log(...args) {
+    if (!args.length) return;
+
     const level = 'INFO';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -194,6 +206,8 @@ class Logger {
   }
 
   trace(...args) {
+    if (!args.length) return;
+
     const level = 'TRACE';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -209,6 +223,8 @@ class Logger {
   }
 
   warn(...args) {
+    if (!args.length) return;
+
     const level = 'WARN';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
@@ -233,7 +249,7 @@ class Logger {
    */
   intercept(userLogger) {
     if (!userLogger) return;
-    debug(`Intercepting user logger`);
+    debug(`User logger intercepted`);
 
     // save original user logger to use it for logging (last intercepted will be used for console output)
     this._originalUserLogger = { ...userLogger };
@@ -275,4 +291,3 @@ module.exports = new Logger();
 
 // TODO: parse passed arguments as {level: 'str', message: 'str'} because some loggers use such syntax;
 // upd: did not face such loggers, but still could be useful
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.2.2-beta",
+  "version": "1.2.3-beta",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",
@@ -51,7 +51,6 @@
     "test:adapter:cucumber:example": "cd ./tests/adapter/examples/cucumber && npx cucumber-js"
   },
   "devDependencies": {
-    "@cucumber/cucumber": "^8.6.0",
     "@redocly/cli": "^1.0.0-beta.125",
     "@wdio/reporter": "^7.16.13",
     "chai": "^4.3.6",