@testomatio/reporter 1.2.4-beta → 1.3.0-beta

package/lib/adapter/cucumber/current.js

@@ -1,4 +1,4 @@
-// eslint-disable-next-line global-require, import/no-extraneous-dependencies
+// eslint-disable-next-line global-require, import/no-extraneous-dependencies, import/no-unresolved
 const { Formatter, formatterHelpers } = require('@cucumber/cucumber');
 const chalk = require('chalk');
 const fs = require('fs');
@@ -29,7 +29,7 @@ class CucumberReporter extends Formatter {
     this.failures = [];
     this.cases = [];
 
-    this.client = new TestomatClient();
+    this.client = new TestomatClient({ apiKey: options.apiKey || process.env.TESTOMATIO });
     this.status = STATUS.PASSED;
 
     global.testomatioRunningEnvironment = 'cucumber:current';

package/lib/adapter/cucumber/legacy.js

@@ -125,8 +125,8 @@ const createTestomatFormatter = apiKey => {
 
       if (!scenario.name) return;
 
-      let message = '';
-      let cliMessage = `- ${scenario.name}: ${chalk.bold(status.toUpperCase())}`;
+      const message = '';
+      const cliMessage = `- ${scenario.name}: ${chalk.bold(status.toUpperCase())}`;
 
       // if (event.result.status === 'undefined') {
       //   cliMessage += chalk.yellow(

package/lib/adapter/playwright.js

@@ -7,11 +7,10 @@ const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE } = require('../constan
 const TestomatioClient = require('../client');
 const { isArtifactsEnabled } = require('../fileUploader');
 const { parseTest, fileSystem } = require('../util');
-const { setCurrentlyRunningTestId } = require('../helpers');
 
 const reportTestPromises = [];
 
-class TestomatioReporter {
+class PlaywrightReporter {
   constructor(config = {}) {
     this.client = new TestomatioClient({ apiKey: config?.apiKey });
 
@@ -19,24 +18,18 @@ class TestomatioReporter {
   }
 
   onBegin(_config, suite) {
+    // clean data storage
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
     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;
-  }
+  // onTestBegin(test) {
+  //   const testId = parseTest(test.title);
+  // }
 
   onTestEnd(test, result) {
-    // reset currently running test id
-    // setCurrentlyRunningTestId('');
     if (!this.client) return;
 
     let testId = parseTest(test.title);
@@ -51,25 +44,23 @@ class TestomatioReporter {
       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 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)
       });
+    });
 
     reportTestPromises.push(reportTestPromise);
   }
@@ -140,4 +131,4 @@ function tmpFile(prefix = 'tmp.') {
   return path.join(tmpdir, prefix + crypto.randomBytes(16).toString('hex'));
 }
 
-module.exports = TestomatioReporter;
+module.exports = PlaywrightReporter;

package/lib/client.js

@@ -38,7 +38,7 @@ class Client {
    */
   createRun() {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
+    if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
     const runParams = {
       title: this.title,
@@ -67,7 +67,7 @@ class Client {
    */
   async addTestRun(status, testData, storeArtifacts = []) {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return;
+    if (!this.pipes?.filter(p => p.isEnabled).length) return [];
 
     if (!testData)
       testData = {
@@ -92,7 +92,7 @@ class Client {
 
     const uploadedFiles = [];
 
-    let stack = testData.stack || '';
+    let stack = '';
 
     if (error) {
       stack = this.formatError(error) || '';
@@ -102,8 +102,10 @@ class Client {
       stack += this.formatSteps(stack, steps);
     }
 
+    stack += testData.stack || '';
+
     // 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('./logger');
     const testLogs = logger.getLogs(test_id);
     // debug(`Test logs for ${test_id}:\n`, testLogs);
     if (stack) stack += '\n\n';
@@ -151,17 +153,19 @@ class Client {
       artifacts,
     };
 
-    this.queue = this.queue
-      .then(() => Promise.all(this.pipes.map(async p => {
-        try {
-          const result = await p.addTest(data);
-          return { pipe: p.toString(), result };
-        } catch (err) {
-          console.log(APP_PREFIX, p.toString(), err);
-        }
-      }
-    )));
-    
+    this.queue = this.queue.then(() =>
+      Promise.all(
+        this.pipes.map(async p => {
+          try {
+            const result = await p.addTest(data);
+            return { pipe: p.toString(), result };
+          } catch (err) {
+            console.log(APP_PREFIX, p.toString(), err);
+          }
+        }),
+      ),
+    );
+
     return this.queue;
   }
 
@@ -174,7 +178,7 @@ class Client {
    */
   updateRunStatus(status, isParallel = false) {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
+    if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
     const runParams = { status, parallel: isParallel };
 

package/lib/dataStorage.js

@@ -6,7 +6,8 @@ const { join } = require('path');
 const JestReporter = require('./adapter/jest');
 const { TESTOMAT_TMP_STORAGE } = require('./constants');
 const { fileSystem } = require('./util');
-// const { getCurrentlyRunningTestId } = require('./helpers');
+const getTestIdFromTestTitle = require('./util').parseTest;
+
 class DataStorage {
   /**
    * Creates data storage instance for specific data type.
@@ -28,34 +29,6 @@ class DataStorage {
     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.
-      But if, for example, we create storage instance inside the testomatio client (to get stored data),
-      the environment could be different (not already a test runner env).
-      Thus, checking environment is only reasonable when you put data to starage 
-      and potentially useless when get data from storage
-    */
-    this.runningEnvironment = this.getRunningEnviroment();
-
-    // 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;
-  }
-
   /**
    * Try to define the running environment. Not 100% reliable and used as additional check
    * @returns jest | mocha | ...
@@ -94,18 +67,13 @@ class DataStorage {
   putData(data, context = null) {
     this._refreshStorageType();
 
-    let testId = null;
-    if (typeof context === 'string') {
-      testId = context;
-    } else {
-      // TODO: derive testId from context
-      // testId = context...
-    }
+    let testId = this._tryToRetrieveTestId(context) || null;
 
-    // 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();
+    if (this.runningEnvironment === 'jest') testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
+    // logs in playwright are gathered by pw framwork itself
+    if (this.runningEnvironment === 'playwright' && this.dataType === 'log') return;
+
     // get id from global store
     if (global.testomatioDataStore && global.testomatioDataStore.currentlyRunningTestId)
       testId = testId ?? global.testomatioDataStore?.currentlyRunningTestId;
@@ -164,6 +132,52 @@ class DataStorage {
     return testData;
   }
 
+  /**
+   * This method is named as "try" because it does not guarantee that test id could be retrieved.
+   * Context could be anything (test, suite, string, etc) which is used to define testId.
+   * Or it could represent any other entity (which does not contain test id).
+   * @param {*} context
+   */
+  _tryToRetrieveTestId(context) {
+    if (!context) return null;
+    this._refreshStorageType();
+
+    if (this.runningEnvironment === 'playwright' || context?.title) {
+      // context is testInfo
+      const testId = getTestIdFromTestTitle(context.title);
+      if (testId) return testId;
+    }
+
+    if (typeof context === 'string') {
+      const testId = getTestIdFromTestTitle(context);
+      if (testId) return testId;
+    }
+
+    return null;
+  }
+
+  /**
+   * 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. And storage type could be changed
+   */
+  _refreshStorageType() {
+    this.isFileStorage = !global.testomatioDataStore;
+    /*
+        FYI:
+        If this storage instance is used within test runner, it works fine.
+        But if, for example, we create storage instance inside the testomatio client (to get stored data),
+        the environment could differs (not already a test runner environment).
+        Thus, checking environment is only reasonable when you put data to starage
+        (to define where to put data - to global variable or to file)
+        and potentially useless when getting data from storage
+      */
+    this.runningEnvironment = this.getRunningEnviroment();
+
+    // some test frameworks do not persist global variables, thus file storage is used for them
+    if (this.runningEnvironment === 'jest') this.isFileStorage = true;
+  }
+
   _getDataFromGlobalVar(testId) {
     try {
       if (global?.testomatioDataStore[this.dataDirName]) {
@@ -224,18 +238,7 @@ module.exports.DataStorage = DataStorage;
 // TODO: use .env
 // 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/logger.js

@@ -34,44 +34,24 @@ class Logger {
     // commented because prefer to use "intercept" method
     // if (params?.logger) this._loggerToIntercept = params.logger;
 
-    this.intercept(this._loggerToIntercept);
+    // intercept console by default
+    this.intercept(console);
 
     // singleton
     if (!Logger.instance) {
       Logger.instance = this;
     }
-  }
 
-  /**
-   * Tagget template literal. Allows to use different syntaxes:
-   * 1. Tagget template: $`text ${someVar}`
-   * 2. Standard: $(`text ${someVar}`)
-   * 3. Standard with multiple arguments: $('text', someVar)
-   */
-  _log(strings, ...args) {
-    let logs;
-    // this block means tagged template is used (syntax like $`text ${someVar}`)
-    if (Array.isArray(strings) && strings.length === args.length + 1) {
-      logs = strings.reduce(
-        (result, current, index) =>
-          result +
-          current +
-          // strings are splitted by args when use tagged template, thus we add arg after each string
-          // it looks like: `string1 arg1 string2 arg2 string3`
-          (args[index] !== undefined // eslint-disable-line no-nested-ternary
-            ? typeof args[index] === 'string'
-              ? args[index] // add arg as it is
-              : this._strinfifyLogs(args[index]) // stringify arg
-            : ' '), // add space if no arg after string
-        // initial accumulator value
-        '',
-      );
-    } else {
-      // this block means arguments syntax is used (syntax like $('text', someVar))
-      // in this case strings represents just a first argument
-      logs = this._strinfifyLogs(strings, ...args);
-    }
-    this.dataStorage.putData(logs);
+    this._helpers = {
+      parseLastArgToGetTestId: (...args) => {
+        try {
+          return this.dataStorage._tryToRetrieveTestId(args.at(-1));
+        } catch (e) {
+          // node 14 support
+          return this.dataStorage._tryToRetrieveTestId(args[args.length - 1]);
+        }
+      },
+    };
   }
 
   /**
@@ -102,12 +82,16 @@ class Logger {
     return logs || '';
   }
 
-  _strinfifyLogs(...args) {
+  _stringifyLogs(...args) {
     const logs = [];
     // stringify everything except strings
     for (const arg of args) {
+      // ignore empty strings
+      if (arg === '') continue;
       if (typeof arg === 'string') {
         logs.push(arg);
+      } else if (Array.isArray(arg)) {
+        logs.push(arg.join(' '));
       } else {
         try {
           // eslint-disable-next-line no-unused-expressions
@@ -121,138 +105,153 @@ class Logger {
     return logs.join(' ');
   }
 
-  assert(...args) {
-    // sometimes user invokes logger without any arguments passed
-    if (!args.length) return;
+  /**
+   * Tagget template literal. Allows to use different syntaxes:
+   * 1. Tagget template: $`text ${someVar}`
+   * 2. Standard: $(`text ${someVar}`)
+   * 3. Standard with multiple arguments: $('text', someVar)
+   */
+  _log(strings, ...args) {
+    // entity which is used to define testId
+    let context = null;
+    // last argument could contain testId
+    const testId = this._helpers.parseLastArgToGetTestId(...args);
+    if (testId) {
+      // last arg is test id, do not log it
+      context = args.pop();
+    }
 
-    const level = 'ERROR';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
+    // filter empty strings
+    strings = strings.filter(item => item !== '');
 
-    const logs = this._strinfifyLogs(...args);
-    this.dataStorage.putData(logs);
-    try {
-      this._originalUserLogger.log(`Assertion result: `, ...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
+    let logs;
+    // this block means tagged template is used (syntax like $`text ${someVar}`)
+    if (Array.isArray(strings) && strings.length === args.length + 1) {
+      logs = strings.reduce(
+        (result, current, index) =>
+          result +
+          current +
+          // strings are splitted by args when use tagged template, thus we add arg after each string
+          // it looks like: `string1 arg1 string2 arg2 string3`
+          (args[index] !== undefined // eslint-disable-line no-nested-ternary
+            ? typeof args[index] === 'string'
+              ? args[index] // add arg as it is
+              : this._stringifyLogs(args[index]) // stringify arg
+            : ' '), // add space if no arg after string
+        // initial accumulator value
+        '',
+      );
+    } else {
+      // this block means arguments syntax is used (syntax like $('text', someVar))
+      // in this case strings represents just a first argument
+      logs = this._stringifyLogs(strings, ...args);
     }
+    this._originalUserLogger.log(logs);
+    this.dataStorage.putData(logs, context);
   }
 
-  debug(...args) {
-    if (!args.length) return;
+  /**
+   * This function is a wrapper for all logging methods (not to repeat the same code)
+   * @param {*} argsArray
+   * @param {*} level
+   * @returns
+   */
+  _logWrapper(argsArray, level) {
+    if (!argsArray.length) return;
+
+    // entity which is used to define testId
+    let context = null;
+    // last argument could contain testId
+    const testId = this._helpers.parseLastArgToGetTestId(...argsArray);
+    if (testId) {
+      // last arg is test id, do not log it
+      context = argsArray.pop();
+    }
 
-    const level = 'DEBUG';
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
 
-    if (this.logLevel === 'error' || this.logLevel === 'warn') return;
-    const logs = this._strinfifyLogs(...args);
+    const logs = this._stringifyLogs(...argsArray);
     const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.dataStorage.putData(colorizedLogs);
+    this.dataStorage.putData(colorizedLogs, context);
     try {
-      this._originalUserLogger.debug(...args);
+      // level.toLowerCase() represents method name (log, warn, error, etc)
+      this._originalUserLogger[level.toLowerCase()](colorizedLogs);
     } catch (e) {
       // method could be unexisting, ignore error
     }
   }
 
-  error(...args) {
+  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;
 
-    const logs = this._strinfifyLogs(...args);
-    const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.dataStorage.putData(colorizedLogs);
+    const logs = this._stringifyLogs(...args);
+    this.dataStorage.putData(logs);
     try {
-      this._originalUserLogger.error(...args);
+      this._originalUserLogger.log(`Assertion result: `, ...args);
     } catch (e) {
       // method could be unexisting, ignore error
     }
   }
 
-  info(...args) {
-    if (!args.length) return;
+  debug(...args) {
+    this._logWrapper(args, 'DEBUG');
+  }
 
-    const level = 'INFO';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
+  error(...args) {
+    this._logWrapper(args, 'ERROR');
+  }
 
-    const logs = this._strinfifyLogs(...args);
-    this.dataStorage.putData(logs);
-    try {
-      this._originalUserLogger.info(...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
-    }
+  info(...args) {
+    this._logWrapper(args, 'INFO');
   }
 
   log(...args) {
-    if (!args.length) return;
-
-    const level = 'INFO';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
-
-    const logs = this._strinfifyLogs(...args);
-    this.dataStorage.putData(logs);
-    try {
-      this._originalUserLogger.log(...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
-    }
+    this._logWrapper(args, 'LOG');
   }
 
   trace(...args) {
-    if (!args.length) return;
-
-    const level = 'TRACE';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
-
-    const logs = this._strinfifyLogs(...args);
-    const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.dataStorage.putData(colorizedLogs);
-    try {
-      this._originalUserLogger.trace(...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
-    }
+    this._logWrapper(args, 'TRACE');
   }
 
   warn(...args) {
-    if (!args.length) return;
-
-    const level = 'WARN';
-    const severity = LEVELS[level].severity;
-    if (severity < LEVELS[this.logLevel]?.severity) return;
-
-    const logs = this._strinfifyLogs(...args);
-    const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.dataStorage.putData(colorizedLogs);
-    try {
-      this._originalUserLogger.warn(...args);
-    } catch (e) {
-      // method could be unexisting, ignore error
-    }
+    this._logWrapper(args, 'WARN');
   }
 
   /**
    * Intercepts user logger messages.
    * When call this method, Logger start to control the user logger,
-   * but almost nothing is changed for user ragarding the console output (like log level set by user)
+   * but almost nothing is changed for user regarding the console output (like log level set by user)
    * (until multiple loggers are intercepted,
    * in this case only the last intercepted logger will be used as user console output).
    * @param {*} userLogger
    */
   intercept(userLogger) {
     if (!userLogger) return;
-    debug(`User logger intercepted`);
 
-    // save original user logger to use it for logging (last intercepted will be used for console output)
-    this._originalUserLogger = { ...userLogger };
+    /* prevent multiple console interceptions (cause infinite loop)
+    actual only for "console", because its used as default output and is intercepted by default */
+    const isUserLoggerConsole = userLogger.toString?.().toLowerCase() === '[object console]';
+    if (isUserLoggerConsole && process.env.TESTOMATIO_LOGGER_CONSOLE_INTERCEPTED) {
+      debug(`Try to intercept console, but it is already intercepted`);
+      return;
+    }
+
+    process.env.TESTOMATIO_LOGGER_CONSOLE_INTERCEPTED = 'true';
+    debug(isUserLoggerConsole ? 'console intercepted' : 'User logger intercepted');
+
+    /* logs could be intercepted for playwright only if console provides output, thus adding this exception.
+    it means default _originalUserLogger (console by default) will be used to provide output
+    (for other frameworks user logger will be passed for output) */
+    if (this.dataStorage.runningEnvironment !== 'playwright') {
+      // save original user logger to use it for logging (last intercepted will be used for console output)
+      this._originalUserLogger = { ...userLogger };
+    }
     this._loggerToIntercept = userLogger;
 
     /* 
@@ -287,7 +286,9 @@ class Logger {
 Logger.instance = null;
 
 // module.exports.Logger = Logger;
-module.exports = new Logger();
+const logger = new Logger();
+
+module.exports = 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/lib/util.js

@@ -12,7 +12,9 @@ const debug = require('debug')('@testomatio/reporter:util');
  */
 const parseTest = testTitle => {
   if (!testTitle) return null;
+  
   const captures = testTitle.match(/@T([\w\d]+)/);
+  
   if (captures) {
     return captures[1];
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "1.2.4-beta",
+  "version": "1.3.0-beta",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "typings": "typings/index.d.ts",
@@ -51,10 +51,12 @@
     "test:adapter:cucumber:example": "cd ./tests/adapter/examples/cucumber && npx cucumber-js"
   },
   "devDependencies": {
+    "@cucumber/cucumber": "^9.3.0",
     "@redocly/cli": "^1.0.0-beta.125",
     "@wdio/reporter": "^7.16.13",
     "chai": "^4.3.6",
     "codeceptjs": "^3.2.3",
+    "cucumber": "^6.0.7",
     "eslint": "^8.7.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.3.0",

package/lib/helpers.js

@@ -1,34 +0,0 @@
-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;