@testomatio/reporter 2.0.0-beta-esm → 2.0.0-beta.1-xml

package/src/pipe/debug.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import createDebugMessages from 'debug';
+import { APP_PREFIX } from '../constants.js';
+import prettyMs from 'pretty-ms';
+
+const debug = createDebugMessages('@testomatio/reporter:pipe:debug');
+
+export class DebugPipe {
+  constructor(params, store) {
+    this.params = params || {};
+    this.store = store || {};
+
+    this.isEnabled = !!process.env.TESTOMATIO_DEBUG || !!process.env.DEBUG;
+    if (this.isEnabled) {
+      this.batch = {
+        isEnabled: this.params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+        intervalFunction: null,
+        intervalTime: 5000,
+        tests: [],
+        batchIndex: 0,
+      };
+      this.logFilePath = path.join(os.tmpdir(), `testomatio.debug.${Date.now()}.json`);
+
+      debug('Creating debug file:', this.logFilePath);
+      fs.writeFileSync(this.logFilePath, '');
+      console.log(APP_PREFIX, '🪲. Debug created:');
+      this.testomatioEnvVars = Object.keys(process.env)
+        .filter(key => key.startsWith('TESTOMATIO_'))
+        .reduce((acc, key) => {
+          acc[key] = process.env[key];
+          return acc;
+        }, {});
+      this.logToFile({ datetime: new Date().toISOString(), timestamp: Date.now() });
+      this.logToFile({ data: 'variables', testomatioEnvVars: this.testomatioEnvVars });
+      this.logToFile({ data: 'store', store: this.store || {} });
+      // Bind batchUpload to the instance
+      this.batchUpload = this.batchUpload.bind(this);
+    }
+  }
+
+  /**
+   * Logs data to a file if logging is enabled.
+   *
+   * @param {Object} logData - The data to be logged.
+   * @returns {Promise<void>} A promise that resolves when the log data has been appended to the file.
+   */
+  logToFile(logData) {
+    if (!this.isEnabled) return;
+    const timePassedFromLastAction = Date.now() - (this.lastActionTimestamp || Date.now());
+    this.lastActionTimestamp = Date.now();
+
+    const logLine = JSON.stringify({ t: `+${prettyMs(timePassedFromLastAction)}`, ...logData });
+    fs.appendFileSync(this.logFilePath, `${logLine}\n`);
+  }
+
+  async prepareRun(opts) {
+    if (!this.isEnabled) return [];
+
+    this.logToFile({ action: 'prepareRun', data: opts });
+  }
+
+  async createRun(params = {}) {
+    if (!this.isEnabled) return;
+    if (params.isBatchEnabled === true || params.isBatchEnabled === false) this.batch.isEnabled = params.isBatchEnabled;
+
+    if (!this.isEnabled) return {};
+    if (this.batch.isEnabled) this.batch.intervalFunction = setInterval(this.batchUpload, this.batch.intervalTime);
+
+    this.logToFile({ action: 'createRun', params });
+  }
+
+  async addTest(data) {
+    if (!this.isEnabled) return;
+
+    if (!this.batch.isEnabled) this.logToFile({ action: 'addTest', testId: data });
+    else this.batch.tests.push(data);
+
+    if (!this.batch.intervalFunction) await this.batchUpload();
+  }
+
+  async batchUpload() {
+    this.batch.batchIndex++;
+    if (!this.batch.isEnabled) return;
+    if (!this.batch.tests.length) return;
+
+    const testsToSend = this.batch.tests.splice(0);
+
+    this.logToFile({ action: 'addTestsBatch', tests: testsToSend });
+  }
+
+  async finishRun(params) {
+    if (!this.isEnabled) return;
+    this.logToFile({ actions: 'finishRun', params });
+    await this.batchUpload();
+    if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
+    console.log(APP_PREFIX, '🪲. Debug Saved to', this.logFilePath);
+  }
+
+  toString() {
+    return 'Debug Reporter';
+  }
+}

package/src/pipe/github.js

@@ -3,17 +3,15 @@ import path from 'path';
 import pc from 'picocolors';
 import humanizeDuration from 'humanize-duration';
 import merge from 'lodash.merge';
-import { Octokit } from '@octokit/rest';
 import { APP_PREFIX, testomatLogoURL } from '../constants.js';
 import { ansiRegExp, isSameTest } from '../utils/utils.js';
 import { statusEmoji, fullName } from '../utils/pipe_utils.js';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:github');
 
-
 /**
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  * @class GitHubPipe
  * @implements {Pipe}
  */
@@ -65,6 +63,7 @@ class GitHubPipe {
     if (!this.issue) return;
 
     if (runParams.tests) runParams.tests.forEach(t => this.addTest(t));
+    const { Octokit } = await import('@octokit/rest');
 
     this.octokit = new Octokit({
       auth: this.token,
@@ -155,7 +154,6 @@ class GitHubPipe {
     if (this.tests.length > 0) {
       body += '\n<details>\n<summary><h3>🐢 Slowest Tests</h3></summary>\n\n';
       body += this.tests
-        // eslint-disable-next-line no-unsafe-optional-chaining
         .sort((a, b) => b?.run_time - a?.run_time)
         .slice(0, 5)
         .map(t => `* ${fullName(t)} (${humanizeDuration(parseFloat(t.run_time))})`)

package/src/pipe/gitlab.js

@@ -15,8 +15,8 @@ const debug = createDebugMessages('@testomatio/reporter:pipe:gitlab');
 
 /**
  * @class GitLabPipe
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  */
 class GitLabPipe {
   constructor(params, store = {}) {
@@ -81,13 +81,13 @@ class GitLabPipe {
     let summary = `${this.hiddenCommentData}
     
   | [![Testomat.io Report](${testomatLogoURL})](https://testomat.io)  | ${statusEmoji(
-      runParams.status,
-    )} ${runParams.status.toUpperCase()} ${statusEmoji(runParams.status)} |
+    runParams.status,
+  )} ${runParams.status.toUpperCase()} ${statusEmoji(runParams.status)} |
   | --- | --- |
   | Tests | ✔️  **${this.tests.length}** tests run  |
   | Summary | ${statusEmoji('failed')} **${failedCount}** failed; ${statusEmoji(
-      'passed',
-    )} **${passedCount}** passed; **${statusEmoji('skipped')}** ${skippedCount} skipped |
+    'passed',
+  )} **${passedCount}** passed; **${statusEmoji('skipped')}** ${skippedCount} skipped |
   | Duration | 🕐  **${humanizeDuration(
     parseInt(
       this.tests.reduce((a, t) => a + (t.run_time || 0), 0),
@@ -149,7 +149,6 @@ class GitLabPipe {
     if (this.tests.length > 0) {
       body += '\n<details>\n<summary><h3>🐢 Slowest Tests</h3></summary>\n\n';
       body += this.tests
-        // eslint-disable-next-line no-unsafe-optional-chaining
         .sort((a, b) => b?.run_time - a?.run_time)
         .slice(0, 5)
         .map(t => `* ${fullName(t)} (${humanizeDuration(parseFloat(t.run_time))})`)

package/src/pipe/html.js

@@ -5,9 +5,9 @@ import path from 'path';
 import pc from 'picocolors';
 import handlebars from 'handlebars';
 import fileUrl from 'file-url';
-import { fileSystem, isSameTest, ansiRegExp } from '../utils/utils.js';
+import { fileSystem, isSameTest, ansiRegExp, formatStep } from '../utils/utils.js';
 import { HTML_REPORT } from '../constants.js';
-import { fileURLToPath } from "node:url";
+import { fileURLToPath } from 'node:url';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:html');
 
@@ -66,13 +66,15 @@ class HtmlPipe {
     // empty
   }
 
+  async prepareRun() {}
+
   updateRun() {
     // empty
   }
 
   /**
    * Add test data to the result array for saving. As a result of this function, we get a result object to save.
-   * @param {import('../../types').RunData} test - object which includes each test entry.
+   * @param {import('../../types/types.js').RunData} test - object which includes each test entry.
    */
   addTest(test) {
     if (!this.isEnabled) return;
@@ -128,6 +130,14 @@ class HtmlPipe {
     }
 
     tests.forEach(test => {
+      // steps could be an array or a string
+      test.steps = Array.isArray(test.steps)
+        ? (test.steps = test.steps
+            .map(step => formatStep(step))
+            .flat()
+            .join('\n'))
+        : test.steps;
+
       if (!test.message?.trim()) {
         test.message = "This test has no 'message' code";
       }
@@ -227,7 +237,6 @@ class HtmlPipe {
         </select>`,
         ),
     );
-    /* eslint-disable */
     handlebars.registerHelper('emptyDataComponent', () => {
       const svgFilePath = path.join(__dirname, '..', 'template', 'emptyData.svg');
       const svgContent = fs.readFileSync(svgFilePath, 'utf8');
@@ -244,13 +253,12 @@ class HtmlPipe {
           <div>`,
       );
     });
-    /* eslint-enable */
     handlebars.registerHelper('pageDispleyElements', tests => {
       // We wrapp the lines to the HTML format we need
       const totalTests = JSON.parse(
         JSON.stringify(tests)
           .replace(/<script>/g, '&lt;script&gt;')
-          .replace(/<\/script>/g, '&lt;/script&gt;'), // eslint-disable-line
+          .replace(/<\/script>/g, '&lt;/script&gt;'),
       );
 
       const paginationOptions = {
@@ -277,7 +285,6 @@ class HtmlPipe {
 
       statuses.forEach(status => {
         for (const option in paginationOptions) {
-          // eslint-disable-next-line no-prototype-builtins
           if (paginationOptions.hasOwnProperty(option)) {
             const pageSize = paginationOptions[option];
             let filteredItems = totalTests;

package/src/pipe/index.js

@@ -7,7 +7,8 @@ import GitHubPipe from './github.js';
 import GitLabPipe from './gitlab.js';
 import CsvPipe from './csv.js';
 import HtmlPipe from './html.js';
-import {BitbucketPipe} from './bitbucket.js';
+import { BitbucketPipe } from './bitbucket.js';
+import { DebugPipe } from './debug.js';
 
 export async function pipesFactory(params, opts) {
   const extraPipes = [];
@@ -47,6 +48,7 @@ export async function pipesFactory(params, opts) {
     new CsvPipe(params, opts),
     new HtmlPipe(params, opts),
     new BitbucketPipe(params, opts),
+    new DebugPipe(params, opts),
     ...extraPipes,
   ];
 
@@ -55,13 +57,9 @@ export async function pipesFactory(params, opts) {
   console.log(
     APP_PREFIX,
     pc.cyan('Pipes:'),
-    pc.cyan(
-      pipesEnabled
-        .map(p => p.toString())
-        .join(', ') || 'No pipes enabled',
-    ),
+    pc.cyan(pipesEnabled.map(p => p.toString()).join(', ') || 'No pipes enabled'),
   );
-  
+
   if (!pipesEnabled.length) {
     console.log(
       APP_PREFIX,

package/src/pipe/testomatio.js

@@ -11,18 +11,15 @@ import JsonCycle from 'json-cycle';
 import { APP_PREFIX, STATUS, AXIOS_TIMEOUT, REPORTER_REQUEST_RETRIES } from '../constants.js';
 import { isValidUrl, foundedTestLog } from '../utils/utils.js';
 import { parseFilterParams, generateFilterRequestParams, setS3Credentials } from '../utils/pipe_utils.js';
-import {config} from '../config.js';
+import { config } from '../config.js';
 
 const debug = createDebugMessages('@testomatio/reporter:pipe:testomatio');
 
-
-if (process.env.TESTOMATIO_RUN) {
-  // process.env.runId = process.env.TESTOMATIO_RUN;
-}
+if (process.env.TESTOMATIO_RUN) process.env.runId = process.env.TESTOMATIO_RUN;
 
 /**
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  * @class TestomatioPipe
  * @implements {Pipe}
  */
@@ -64,11 +61,13 @@ class TestomatioPipe {
     this.axios = axios.create({
       baseURL: `${this.url.trim()}`,
       timeout: AXIOS_TIMEOUT,
-      proxy: proxy ? {
-        host: proxy.hostname,
-        port: parseInt(proxy.port, 10),
-        protocol: proxy.protocol,
-      } : false,
+      proxy: proxy
+        ? {
+            host: proxy.hostname,
+            port: parseInt(proxy.port, 10),
+            protocol: proxy.protocol,
+          }
+        : false,
     });
 
     // Pass the axios instance to the retry function
@@ -101,9 +100,10 @@ class TestomatioPipe {
     // do not finish this run (for parallel testing)
     this.proceed = process.env.TESTOMATIO_PROCEED;
     this.jiraId = process.env.TESTOMATIO_JIRA_ID;
-    this.runId = params.runId || process.env.runId;
+    this.runId = params.runId || process.env.TESTOMATIO_RUN;
     this.createNewTests = params.createNewTests ?? !!process.env.TESTOMATIO_CREATE;
     this.hasUnmatchedTests = false;
+    this.requestFailures = 0;
 
     if (!isValidUrl(this.url.trim())) {
       this.isEnabled = false;
@@ -155,9 +155,9 @@ class TestomatioPipe {
    */
   async createRun(params = {}) {
     this.batch.isEnabled = params.isBatchEnabled ?? this.batch.isEnabled;
-    debug('Creating run...');
     if (!this.isEnabled) return;
-    if (this.batch.isEnabled) this.batch.intervalFunction = setInterval(this.#batchUpload, this.batch.intervalTime);
+    if (this.batch.isEnabled && this.isEnabled)
+      this.batch.intervalFunction = setInterval(this.#batchUpload, this.batch.intervalTime);
 
     let buildUrl = process.env.BUILD_URL || process.env.CI_JOB_URL || process.env.CIRCLE_BUILD_URL;
 
@@ -197,12 +197,14 @@ class TestomatioPipe {
     debug(' >>>>>> Run params', JSON.stringify(runParams, null, 2));
 
     if (this.runId) {
+      this.store.runId = this.runId;
       debug(`Run with id ${this.runId} already created, updating...`);
       const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
       if (resp.data.artifacts) setS3Credentials(resp.data.artifacts);
       return;
     }
 
+    debug('Creating run...');
     try {
       const resp = await this.axios.post(`/api/reporter`, runParams, {
         maxContentLength: Infinity,
@@ -222,10 +224,14 @@ class TestomatioPipe {
       process.env.runId = this.runId;
       debug('Run created', this.runId);
     } catch (err) {
+      const errorText = err.response?.data?.message || err.message;
+      console.log(errorText || err);
+      if (!this.apiKey) console.error('Testomat.io API key is not set');
+      if (!this.apiKey?.startsWith('tstmt')) console.error('Testomat.io API key is invalid');
+
       console.error(
         APP_PREFIX,
-        'Error creating Testomat.io report, please check if your API key is valid. Skipping report | ',
-        err?.response?.statusText || err?.status || err.message,
+        'Error creating Testomat.io report (see details above), please check if your API key is valid. Skipping report',
       );
       printCreateIssue(err);
     }
@@ -234,37 +240,25 @@ class TestomatioPipe {
 
   /**
    * Decides whether to skip test reporting in case of too many request failures
-   * @param {TestData} testData
    * @returns {boolean}
    */
-  #cancelTestReportingInCaseOfTooManyReqFailures(testData) {
-    if (this.reportingCanceledDueToReqFailures) return true;
-
-    const retriesCountWithinTime = this.retriesTimestamps.filter(
-      timestamp => Date.now() - timestamp < REPORTER_REQUEST_RETRIES.withinTimeSeconds * 1000,
-    ).length;
-    debug(`${retriesCountWithinTime} failed requests within ${REPORTER_REQUEST_RETRIES.withinTimeSeconds}s`);
-
-    if (retriesCountWithinTime > REPORTER_REQUEST_RETRIES.maxTotalRetries) {
-      const errorMessage = pc.yellow(
-        `${retriesCountWithinTime} requests were failed within ${REPORTER_REQUEST_RETRIES.withinTimeSeconds}s,\
- reporting for test "${testData.title}" to Testomat is skipped`,
-      );
-      console.warn(`${APP_PREFIX} ${errorMessage}`);
+  #cancelTestReportingInCaseOfTooManyReqFailures() {
+    if (!process.env.TESTOMATIO_MAX_REQUEST_FAILURES) return;
 
+    const cancelReporting = this.requestFailures >= parseInt(process.env.TESTOMATIO_MAX_REQUEST_FAILURES, 10);
+    if (cancelReporting) {
       this.reportingCanceledDueToReqFailures = true;
-      this.notReportedTestsCount++;
-
-      return true;
+      let errorMessage = `⚠️ ${process.env.TESTOMATIO_MAX_REQUEST_FAILURES}`;
+      errorMessage += ' requests were failed, reporting to Testomat aborted.';
+      console.warn(`${APP_PREFIX} ${pc.yellow(errorMessage)}`);
     }
-
-    return false;
+    return cancelReporting;
   }
 
   #uploadSingleTest = async data => {
     if (!this.isEnabled) return;
     if (!this.runId) return;
-    if (this.#cancelTestReportingInCaseOfTooManyReqFailures(data)) return;
+    if (this.#cancelTestReportingInCaseOfTooManyReqFailures()) return;
 
     data.api_key = this.apiKey;
     data.create = this.createNewTests;
@@ -277,40 +271,41 @@ class TestomatioPipe {
 
     debug('Adding test', json);
 
-    return this.axios
-      .post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig)
-      .catch(err => {
-        if (err.response) {
-          if (err.response.status >= 400) {
-            const responseData = err.response.data || { message: '' };
-            console.log(
-              APP_PREFIX,
-              pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
-              pc.gray(data?.title || ''),
-            );
-            if (err.response?.data?.message?.includes('could not be matched')) {
-              this.hasUnmatchedTests = true;
-            }
-            return;
-          }
+    return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig).catch(err => {
+      this.requestFailures++;
+      this.notReportedTestsCount++;
+      if (err.response) {
+        if (err.response.status >= 400) {
+          const responseData = err.response.data || { message: '' };
           console.log(
             APP_PREFIX,
-            pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
-            `Report couldn't be processed: ${err?.response?.data?.message}`,
+            pc.yellow(`Warning: ${responseData.message} (${err.response.status})`),
+            pc.gray(data?.title || ''),
           );
-          printCreateIssue(err);
-        } else {
-          console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
+          if (err.response?.data?.message?.includes('could not be matched')) {
+            this.hasUnmatchedTests = true;
+          }
+          return;
         }
-      });
-    };
-    
+        console.log(
+          APP_PREFIX,
+          pc.yellow(`Warning: ${data?.title || ''} (${err.response?.status})`),
+          `Report couldn't be processed: ${err?.response?.data?.message}`,
+        );
+        printCreateIssue(err);
+      } else {
+        console.log(APP_PREFIX, pc.blue(data?.title || ''), "Report couldn't be processed", err);
+      }
+    });
+  };
 
   /**
    * Uploads tests as a batch (multiple tests at once). Intended to be used with a setInterval
    */
   #batchUpload = async () => {
     if (!this.batch.isEnabled) return;
+    if (!this.batch.tests.length) return;
+    if (this.#cancelTestReportingInCaseOfTooManyReqFailures()) return;
     // prevent infinite loop
     if (this.batch.numberOfTimesCalledWithoutTests > 10) {
       debug('📨 Batch upload: no tests to send for 10 times, stopping batch');
@@ -322,7 +317,7 @@ class TestomatioPipe {
       this.batch.numberOfTimesCalledWithoutTests++;
       return;
     }
-    
+
     this.batch.batchIndex++;
     // get tests from batch and clear batch
     const testsToSend = this.batch.tests.splice(0);
@@ -335,6 +330,8 @@ class TestomatioPipe {
         axiosAddTestrunRequestConfig,
       )
       .catch(err => {
+        this.requestFailures++;
+        this.notReportedTestsCount += testsToSend.length;
         if (err.response) {
           if (err.response.status >= 400) {
             const responseData = err.response.data || { message: '' };
@@ -380,14 +377,21 @@ class TestomatioPipe {
   }
 
   /**
-   * @param {import('../../types').RunData} params
+   * @param {import('../../types/types.js').RunData} params
    * @returns
    */
   async finishRun(params) {
     if (!this.isEnabled) return;
-    
-    if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
+
     await this.#batchUpload();
+    if (this.batch.intervalFunction) {
+      clearInterval(this.batch.intervalFunction);
+      // this code is required in case test is added after run is finished
+      // (e.g. if test has artifacts, add test function will be invoked only after artifacts are uploaded)
+      // batch stops working after run is finished; thus, disable it to use single test uploading
+      this.batch.intervalFunction = null;
+      this.batch.isEnabled = false;
+    }
 
     debug('Finishing run...');
 
@@ -411,7 +415,9 @@ class TestomatioPipe {
       if (this.runId && !this.proceed) {
         await this.axios.put(`/api/reporter/${this.runId}`, {
           api_key: this.apiKey,
+          duration: params.duration,
           status_event,
+          detach: params.detach,
           tests: params.tests,
         });
         if (this.runUrl) {
@@ -426,16 +432,14 @@ class TestomatioPipe {
         console.log(APP_PREFIX, `📊 ${notFinishedMessage}. Report URL: ${pc.magenta(this.runUrl)}`);
         console.log(APP_PREFIX, `🛬 Run to finish it: TESTOMATIO_RUN=${this.runId} npx start-test-run --finish`);
       }
+
       if (this.hasUnmatchedTests) {
         console.log('');
-        // eslint-disable-next-line max-len
         console.log(APP_PREFIX, pc.yellow(pc.bold('⚠️ Some reported tests were not found in Testomat.io project')));
-        // eslint-disable-next-line max-len
         console.log(
           APP_PREFIX,
           `If you use Testomat.io as a reporter only, please re-run tests using ${pc.bold('TESTOMATIO_CREATE=1')}`,
         );
-        // eslint-disable-next-line max-len
         console.log(
           APP_PREFIX,
           `But to keep your tests consistent it is recommended to ${pc.bold('import tests first')}`,
@@ -444,12 +448,7 @@ class TestomatioPipe {
         console.log(APP_PREFIX, 'You can do that automatically via command line tools:');
         console.log(APP_PREFIX, pc.bold('npx check-tests ... --update-ids'), 'See: https://bit.ly/js-update-ids');
         console.log(APP_PREFIX, 'or for Cucumber:');
-        // eslint-disable-next-line max-len
-        console.log(
-          APP_PREFIX,
-          pc.bold('npx check-cucumber ... --update-ids'),
-          'See: https://bit.ly/bdd-update-ids',
-        );
+        console.log(APP_PREFIX, pc.bold('npx check-cucumber ... --update-ids'), 'See: https://bit.ly/bdd-update-ids');
       }
     } catch (err) {
       console.log(APP_PREFIX, 'Error updating status, skipping...', err);
@@ -473,7 +472,7 @@ function printCreateIssue(err) {
     console.log(
       APP_PREFIX,
       'If you think this is a bug please create an issue: https://github.com/testomatio/reporter/issues/new',
-    ); // eslint-disable-line max-len
+    );
     console.log(APP_PREFIX, 'Provide this information:');
     console.log('Error:', err.message || err.code);
     if (!err.config) return;

package/src/reporter-functions.js

@@ -1,38 +1,49 @@
 import { services } from './services/index.js';
-import { initPlaywrightForStorage } from './adapter/playwright.js';
-
-if (process.env.PLAYWRIGHT_TEST_BASE_URL) initPlaywrightForStorage();
 
 /**
  * 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 (process.env.IS_PLAYWRIGHT)
+    throw new Error(`This function is not available in Playwright framework.
+    /Playwright supports artifacts out of the box`);
   if (!data) return;
   services.artifacts.put(data, context);
 }
 
 /**
  * Attach log message(s) to the test report
- * @param  {...any} args
+ * @param  string
  */
 function logMessage(...args) {
+  if (process.env.IS_PLAYWRIGHT) throw new Error('This function is not available in Playwright framework');
   services.logger._templateLiteralLog(...args);
 }
 
 /**
  * Similar to "log" function but marks message in report as a step
- * @param {*} message
+ * @param {string} message
  */
 function addStep(message) {
+  if (process.env.IS_PLAYWRIGHT)
+    throw new Error('This function is not available in Playwright framework. Use playwright steps');
+
   services.logger.step(message);
 }
 
 /**
  * Add key-value pair(s) to the test report
- * @param {*} keyValue
+ * @param {{[key: string]: string} | string} keyValue object { key: value } (multiple props allowed) or key (string)
+ * @param {string?} value
  */
-function setKeyValue(keyValue) {
+function setKeyValue(keyValue, value = null) {
+  if (process.env.IS_PLAYWRIGHT)
+    throw new Error('This function is not available in Playwright framework. Use test tag instead.');
+
+  if (typeof keyValue === 'string') {
+    keyValue = { [keyValue]: value };
+  }
   services.keyValues.put(keyValue);
 }
 

package/src/reporter.cjs_decprecated

@@ -0,0 +1,21 @@
+// const _reporter = require('../lib/reporter.js');
+
+
+// /**
+//  * @typedef {import('../lib/reporter-functions.js').saveArtifact} artifact
+//  * @typedef {import('../lib/reporter-functions.js').log} log
+//  * @typedef {import('../lib/reporter-functions.js').logger} logger
+//  * @typedef {import('../lib/reporter-functions.js')} meta
+//  * @typedef {import('../lib/reporter-functions.js')} step
+//  * 
+//  * "Reporter" type which is object containing all types from the above
+//  * @typedef {{artifact: artifact, log: log, logger: logger, meta: meta, step: step, }} Reporter
+//  */
+
+// // const reporter = _reporter;
+
+// /**
+//  * @type {Reporter}
+//  */
+// const reporter = _reporter;
+// module.exports = reporter;