@testomatio/reporter 2.0.0-beta-esm → 2.0.1-beta-esm

package/lib/client.js

@@ -33,32 +33,34 @@ const minimatch_1 = require("minimatch");
 const fs_1 = __importDefault(require("fs"));
 const picocolors_1 = __importDefault(require("picocolors"));
 const crypto_1 = require("crypto");
-const fileUploader_js_1 = require("./fileUploader.js");
 const constants_js_1 = require("./constants.js");
 const index_js_1 = require("./pipe/index.js");
 const glob_1 = require("glob");
 const path_1 = __importStar(require("path"));
 const node_url_1 = require("node:url");
+const uploader_js_1 = require("./uploader.js");
+const utils_js_1 = require("./utils/utils.js");
+const filesize_1 = require("filesize");
 const debug = (0, debug_1.default)('@testomatio/reporter:client');
 // removed __dirname usage, because:
 // 1. replaced with ESM syntax (import.meta.url), but it throws an error on tsc compilation;
-// 2. got error "__dirname already defined" in compiles js code (cjs dir) 
+// 2. got error "__dirname already defined" in compiles js code (cjs dir)
 let listOfTestFilesToExcludeFromReport = null;
 /**
- * @typedef {import('../types').TestData} TestData
- * @typedef {import('../types').PipeResult} PipeResult
+ * @typedef {import('../types/types.js').TestData} TestData
+ * @typedef {import('../types/types.js').PipeResult} PipeResult
  */
 class Client {
     /**
      * Create a Testomat client instance
      * @returns
      */
-    // eslint-disable-next-line 
+    // eslint-disable-next-line
     constructor(params = {}) {
-        this.uuid = (0, crypto_1.randomUUID)();
+        this.paramsForPipesFactory = params;
+        this.pipeStore = {};
+        this.runId = (0, crypto_1.randomUUID)(); // will be replaced by real run id
         this.queue = Promise.resolve();
-        this.totalUploaded = 0;
-        this.failedToUpload = 0;
         // @ts-ignore this line will be removed in compiled code, because __dirname is defined in commonjs
         const pathToPackageJSON = path_1.default.join(__dirname, '../package.json');
         try {
@@ -69,6 +71,7 @@ class Client {
             // do nothing
         }
         this.executionList = Promise.resolve();
+        this.uploader = new uploader_js_1.S3Uploader();
     }
     /**
      * Asynchronously prepares the execution list for running tests through various pipes.
@@ -87,8 +90,7 @@ class Client {
      * or resolves to undefined if no valid results are found or if all pipes are disabled.
      */
     async prepareRun(params) {
-        const store = {};
-        this.pipes = await (0, index_js_1.pipesFactory)(params, store);
+        this.pipes = await (0, index_js_1.pipesFactory)(params || this.paramsForPipesFactory || {}, this.pipeStore);
         const { pipe, pipeOptions } = params;
         // all pipes disabled, skipping
         if (!this.pipes.some(p => p.isEnabled)) {
@@ -120,7 +122,7 @@ class Client {
      */
     async createRun(params) {
         if (!this.pipes || !this.pipes.length)
-            this.pipes = await (0, index_js_1.pipesFactory)(params || {}, {});
+            this.pipes = await (0, index_js_1.pipesFactory)(params || this.paramsForPipesFactory || {}, this.pipeStore);
         debug('Creating run...');
         // all pipes disabled, skipping
         if (!this.pipes?.filter(p => p.isEnabled).length)
@@ -128,6 +130,13 @@ class Client {
         this.queue = this.queue
             .then(() => Promise.all(this.pipes.map(p => p.createRun())))
             .catch(err => console.log(constants_js_1.APP_PREFIX, err))
+            .then(() => {
+            const runId = this.pipeStore?.runId;
+            if (runId)
+                this.runId = runId;
+            (0, utils_js_1.storeRunId)(this.runId);
+        })
+            .then(() => this.uploader.checkEnabled())
             .then(() => undefined); // fixes return type
         // debug('Run', this.queue);
         return this.queue;
@@ -157,8 +166,45 @@ class Client {
         /**
          * @type {TestData}
          */
-        const { rid, error = null, time = 0, example = null, files = [], filesBuffers = [], steps, code = null, title, file, suite_title, suite_id, test_id, manuallyAttachedArtifacts, meta, } = testData;
-        let { message = '' } = testData;
+        const { rid, error = null, time = 0, example = null, files = [], filesBuffers = [], steps, code = null, title, file, suite_title, suite_id, test_id, manuallyAttachedArtifacts, } = testData;
+        let { message = '', meta = {} } = testData;
+        // stringify meta values and limit keys and values length to 255
+        meta = Object.entries(meta)
+            .filter(([, value]) => value !== null && value !== undefined)
+            .map(([key, value]) => {
+            try {
+                if (typeof value === 'object') {
+                    value = JSON.stringify(value);
+                }
+                else if (typeof value !== 'string') {
+                    try {
+                        value = value.toString();
+                    }
+                    catch (err) {
+                        console.warn(constants_js_1.APP_PREFIX, `Can't convert meta value to string`, err);
+                    }
+                }
+                if (value?.length > 255) {
+                    value = value.substring(0, 255);
+                    debug(constants_js_1.APP_PREFIX, `Meta info value "${value}" is too long, trimmed to 255 characters`);
+                }
+                if (key?.length > 255) {
+                    const newKey = key.substring(0, 255);
+                    debug(constants_js_1.APP_PREFIX, `Meta info key "${key}" is too long, trimmed to 255 characters`);
+                    return [newKey, value];
+                }
+                return [key, value];
+            }
+            catch (err) {
+                debug(constants_js_1.APP_PREFIX, `Error while processing meta info key ${key}`, err);
+                return [null, null];
+            }
+        })
+            .reduce((acc, [key, value]) => {
+            if (key)
+                acc[key] = value;
+            return acc;
+        }, {});
         let errorFormatted = '';
         if (error) {
             errorFormatted += this.formatError(error) || '';
@@ -170,19 +216,21 @@ class Client {
         if (manuallyAttachedArtifacts?.length)
             files.push(...manuallyAttachedArtifacts);
         const uploadedFiles = [];
-        for (const f of files) {
-            uploadedFiles.push(fileUploader_js_1.upload.uploadFileByPath(f, this.uuid));
+        for (let f of files) {
+            if (!f)
+                continue; // f === null
+            if (typeof f === 'object') {
+                if (!f.path)
+                    continue;
+                f = f.path;
+            }
+            uploadedFiles.push(this.uploader.uploadFileByPath(f, [this.runId, rid, path_1.default.basename(f)]));
         }
         for (const [idx, buffer] of filesBuffers.entries()) {
             const fileName = `${idx + 1}-${title.replace(/\s+/g, '-')}`;
-            uploadedFiles.push(fileUploader_js_1.upload.uploadFileAsBuffer(buffer, fileName, this.uuid));
+            uploadedFiles.push(this.uploader.uploadFileAsBuffer(buffer, [this.runId, rid, fileName]));
         }
         const artifacts = (await Promise.all(uploadedFiles)).filter(n => !!n);
-        if (artifacts.length < uploadedFiles.length) {
-            const failedUploading = uploadedFiles.length - artifacts.length;
-            this.failedToUpload += failedUploading;
-        }
-        this.totalUploaded += artifacts.length;
         const data = {
             rid,
             files,
@@ -232,15 +280,47 @@ class Client {
         this.queue = this.queue
             .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
             .then(() => {
-            debug('TOTAL artifacts', this.totalUploaded);
-            if (this.totalUploaded && !fileUploader_js_1.upload.isArtifactsEnabled())
-                debug(`${this.totalUploaded} artifacts are not uploaded, because artifacts uploading is not enabled`);
-            if (this.totalUploaded && fileUploader_js_1.upload.isArtifactsEnabled()) {
-                console.log(constants_js_1.APP_PREFIX, `🗄️ ${this.totalUploaded} artifacts ${process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : picocolors_1.default.bold('publicly')} uploaded to S3 bucket`);
-                if (this.failedToUpload > 0) {
-                    console.log(constants_js_1.APP_PREFIX, picocolors_1.default.yellow(`Some artifacts were not uploaded. ${this.failedToUpload} artifacts could not be uploaded.
-                Run tests with DEBUG="@testomatio/reporter:file-uploader" to see details"`));
-                }
+            if (!this.uploader.isEnabled)
+                return;
+            const filesizeStrMaxLength = 7;
+            if (this.uploader.successfulUploads.length) {
+                debug('\n', constants_js_1.APP_PREFIX, `🗄️ ${this.uploader.successfulUploads.length} artifacts uploaded to S3 bucket`);
+                const uploadedArtifacts = this.uploader.successfulUploads.map(file => ({
+                    relativePath: file.path.replace(process.cwd(), ''),
+                    link: file.link,
+                    sizePretty: (0, filesize_1.filesize)(file.size, { round: 0 }).toString(),
+                }));
+                uploadedArtifacts.forEach(upload => {
+                    debug(`🟢Uploaded artifact`, `${upload.relativePath},`, 'size:', `${upload.sizePretty},`, 'link:', `${upload.link}`);
+                });
+            }
+            if (this.uploader.failedUploads.length) {
+                console.log(constants_js_1.APP_PREFIX, `🗄️ ${this.uploader.failedUploads.length} artifacts 🔴${picocolors_1.default.bold('failed')} to upload`);
+                const failedUploads = this.uploader.failedUploads.map(file => ({
+                    relativePath: file.path.replace(process.cwd(), ''),
+                    sizePretty: (0, filesize_1.filesize)(file.size, { round: 0 }).toString(),
+                }));
+                const pathPadding = Math.max(...failedUploads.map(upload => upload.relativePath.length)) + 1;
+                failedUploads.forEach(upload => {
+                    console.log(`  ${picocolors_1.default.gray('|')} 🔴 ${upload.relativePath.padEnd(pathPadding)} ${picocolors_1.default.gray(`| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`)}`);
+                });
+            }
+            if (this.uploader.skippedUploads.length) {
+                console.log('\n', constants_js_1.APP_PREFIX, `🗄️ ${picocolors_1.default.bold(this.uploader.skippedUploads.length)} artifacts uploading 🟡${picocolors_1.default.bold('skipped')}`);
+                const skippedUploads = this.uploader.skippedUploads.map(file => ({
+                    relativePath: file.path.replace(process.cwd(), ''),
+                    sizePretty: file.size === null ? 'unknown' : (0, filesize_1.filesize)(file.size, { round: 0 }).toString(),
+                }));
+                const pathPadding = Math.max(...skippedUploads.map(upload => upload.relativePath.length)) + 1;
+                skippedUploads.forEach(upload => {
+                    console.log(`  ${picocolors_1.default.gray('|')} 🟡 ${upload.relativePath.padEnd(pathPadding)} ${picocolors_1.default.gray(`| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`)}`);
+                });
+            }
+            if (this.uploader.skippedUploads.length || this.uploader.failedUploads.length) {
+                const command = `TESTOMATIO=<your_api_key> TESTOMATIO_RUN=${this.runId} npx @testomatio/reporter upload-artifacts`;
+                const numberOfNotUploadedArtifacts = this.uploader.skippedUploads.length + this.uploader.failedUploads.length;
+                console.log(constants_js_1.APP_PREFIX, `${numberOfNotUploadedArtifacts} artifacts were not uploaded.
+            Run "${picocolors_1.default.magenta(command)}" with valid S3 credentials to upload skipped & failed artifacts`);
             }
         })
             .catch(err => console.log(constants_js_1.APP_PREFIX, err));
@@ -255,7 +335,7 @@ class Client {
         logs = logs?.trim();
         if (Array.isArray(steps)) {
             steps = steps
-                .map(step => formatStep(step))
+                .map(step => (0, utils_js_1.formatStep)(step))
                 .flat()
                 .join('\n');
         }
@@ -327,20 +407,6 @@ function isNotInternalFrame(frame) {
         !frame.getFileName().includes('node_modules') &&
         !frame.getFileName().includes('internal'));
 }
-function formatStep(step, shift = 0) {
-    const prefix = ' '.repeat(shift);
-    const lines = [];
-    if (step.error) {
-        lines.push(`${prefix}${picocolors_1.default.red(step.title)} ${picocolors_1.default.gray(`${step.duration}ms`)}`);
-    }
-    else {
-        lines.push(`${prefix}${step.title} ${picocolors_1.default.gray(`${step.duration}ms`)}`);
-    }
-    for (const child of step.steps || []) {
-        lines.push(...formatStep(child, shift + 2));
-    }
-    return lines;
-}
 /**
  *
  * @param {TestData} testData

package/lib/config.d.ts

@@ -0,0 +1 @@
+export const config: NodeJS.ProcessEnv;

package/lib/constants.d.ts

@@ -0,0 +1,25 @@
+export const APP_PREFIX: string;
+export const TESTOMAT_TMP_STORAGE_DIR: string;
+export const CSV_HEADERS: {
+    id: string;
+    title: string;
+}[];
+export namespace STATUS {
+    let PASSED: string;
+    let FAILED: string;
+    let SKIPPED: string;
+    let FINISHED: string;
+}
+export namespace HTML_REPORT {
+    let FOLDER: string;
+    let REPORT_DEFAULT_NAME: string;
+    let TEMPLATE_NAME: string;
+}
+export const AXIOS_TIMEOUT: number;
+export const testomatLogoURL: "https://avatars.githubusercontent.com/u/59105116?s=36&v=4";
+export namespace REPORTER_REQUEST_RETRIES {
+    let retryTimeout: number;
+    let retriesPerRequest: number;
+    let maxTotalRetries: number;
+    let withinTimeSeconds: number;
+}

package/lib/constants.js

@@ -9,7 +9,11 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const APP_PREFIX = picocolors_1.default.gray('[TESTOMATIO]');
 exports.APP_PREFIX = APP_PREFIX;
-const AXIOS_TIMEOUT = 20 * 1000; // sum = 20sec
+const TESTOMATIO_REQUEST_TIMEOUT = parseInt(process.env.TESTOMATIO_REQUEST_TIMEOUT, 10);
+if (TESTOMATIO_REQUEST_TIMEOUT) {
+    console.log(`${APP_PREFIX} Request timeout is set to ${TESTOMATIO_REQUEST_TIMEOUT / 1000}s`);
+}
+const AXIOS_TIMEOUT = TESTOMATIO_REQUEST_TIMEOUT || 20 * 1000;
 exports.AXIOS_TIMEOUT = AXIOS_TIMEOUT;
 const TESTOMAT_TMP_STORAGE_DIR = path_1.default.join(os_1.default.tmpdir(), 'testomatio_tmp');
 exports.TESTOMAT_TMP_STORAGE_DIR = TESTOMAT_TMP_STORAGE_DIR;

package/lib/data-storage.d.ts

@@ -0,0 +1,34 @@
+export const dataStorage: DataStorage;
+declare class DataStorage {
+    static "__#11@#instance": any;
+    /**
+     *
+     * @returns {DataStorage}
+     */
+    static getInstance(): DataStorage;
+    context: any;
+    setContext(context: any): void;
+    isFileStorage: boolean;
+    /**
+     * Puts any data to storage (file or global variable).
+     * If file: stores data as text, if global variable – stores as array of data.
+     * @param {'log' | 'artifact' | 'keyvalue'} dataType
+     * @param {*} data anything you want to store (string, object, array, etc)
+     * @param {*} context could be testId or any context (test name, suite name, including their IDs etc)
+     * suite name + test name is used by default
+     * @returns
+     */
+    putData(dataType: "log" | "artifact" | "keyvalue", data: any, context?: any): void;
+    /**
+     * Returns data, stored for specific test/context (or data which was stored without test id specified).
+     * This method will get data from global variable and/or from from file (previosly saved with put method).
+     *
+     * @param {'log' | 'artifact' | 'keyvalue'} dataType
+     * @param {string} context
+     * @returns {any []} array of data (any type), null (if no data found for context) or string (if data type is log)
+     */
+    getData(dataType: "log" | "artifact" | "keyvalue", context: string): any[];
+    #private;
+}
+export function stringToMD5Hash(str: any): string;
+export {};

package/lib/data-storage.js

@@ -76,7 +76,7 @@ class DataStorage {
             return;
         context = context || this.context || utils_js_1.testRunnerHelper.getNameOfCurrentlyRunningTest();
         if (!context) {
-            debug(`No context provided for "${dataType}" data:`, data);
+            // debug(`No context provided for "${dataType}" data:`, data);
             return;
         }
         const contextHash = stringToMD5Hash(context);
@@ -119,7 +119,7 @@ class DataStorage {
         if (testDataFromFile.length) {
             return testDataFromFile;
         }
-        debug(`No "${dataType}" data for context "${contextHash}" in both file and global variable`);
+        // debug(`No "${dataType}" data for context "${contextHash}" in both file and global variable`);
         // in case no data found for context
         return null;
     }

package/lib/junit-adapter/adapter.d.ts

@@ -0,0 +1,9 @@
+export default Adapter;
+declare class Adapter {
+    constructor(opts: any);
+    opts: any;
+    getFilePath(t: any): any;
+    formatTest(t: any): any;
+    formatStack(t: any): any;
+    formatMessage(t: any): any;
+}

package/lib/junit-adapter/csharp.d.ts

@@ -0,0 +1,4 @@
+export default CSharpAdapter;
+declare class CSharpAdapter extends Adapter {
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/index.d.ts

@@ -0,0 +1,3 @@
+export default AdapterFactory;
+declare function AdapterFactory(lang: any, opts: any): Adapter;
+import Adapter from './adapter.js';

package/lib/junit-adapter/java.d.ts

@@ -0,0 +1,5 @@
+export default JavaAdapter;
+declare class JavaAdapter extends Adapter {
+    getFilePath(t: any): string;
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/javascript.d.ts

@@ -0,0 +1,4 @@
+export default JavaScriptAdapter;
+declare class JavaScriptAdapter extends Adapter {
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/python.d.ts

@@ -0,0 +1,5 @@
+export default PythonAdapter;
+declare class PythonAdapter extends Adapter {
+    getFilePath(t: any): string;
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/ruby.d.ts

@@ -0,0 +1,4 @@
+export default RubyAdapter;
+declare class RubyAdapter extends Adapter {
+}
+import Adapter from './adapter.js';

package/lib/output.d.ts

@@ -0,0 +1,11 @@
+export default Output;
+declare class Output {
+    constructor(opts?: {});
+    filterFn: any;
+    reset(): void;
+    log: any[];
+    start(): void;
+    push(line: any): void;
+    text(): string;
+    stop(): void;
+}

package/lib/package.json

@@ -1 +1,3 @@
-{}
+{
+  "type": "commonjs"
+}

package/lib/pipe/bitbucket.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @class BitbucketPipe
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
+ */
+export class BitbucketPipe {
+    constructor(params: any, store?: {});
+    isEnabled: boolean;
+    ENV: NodeJS.ProcessEnv;
+    store: {};
+    tests: any[];
+    token: any;
+    hiddenCommentData: string;
+    cleanLog(log: any): Promise<string>;
+    prepareRun(): Promise<void>;
+    createRun(): Promise<void>;
+    addTest(test: any): void;
+    finishRun(runParams: any): Promise<void>;
+    toString(): string;
+    updateRun(): void;
+}
+export type Pipe = import("../../types/types.js").Pipe;
+export type TestData = import("../../types/types.js").TestData;

package/lib/pipe/bitbucket.js

@@ -41,8 +41,8 @@ const debug = (0, debug_1.default)('@testomatio/reporter:pipe:bitbucket');
 //! and your pipeline trigger should be a pull request
 /**
  * @class BitbucketPipe
- * @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 BitbucketPipe {
     constructor(params, store = {}) {

package/lib/pipe/csv.d.ts

@@ -0,0 +1,47 @@
+export default CsvPipe;
+export type Pipe = import("../../types/types.js").Pipe;
+export type TestData = import("../../types/types.js").TestData;
+/**
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
+ * @class CsvPipe
+ * @implements {Pipe}
+ */
+declare class CsvPipe implements Pipe {
+    constructor(params: any, store: any);
+    store: any;
+    title: any;
+    results: any[];
+    outputDir: string;
+    defaultReportName: string;
+    csvFilename: string;
+    isEnabled: boolean;
+    outputFile: string;
+    prepareRun(): Promise<void>;
+    createRun(): Promise<void>;
+    updateRun(): void;
+    /**
+     * Create a folder that will contain the exported files
+     */
+    checkExportDir(): void;
+    /**
+     * Save data to the csv file.
+     * @param {Object} data - data that will be added to the CSV file.
+     * Example: [{suite_title: "Suite #1", test: "Test-case-1", message: "Test msg"}]
+     * @param {Object} headers - csv file headers. Example: [{ id: 'suite_title', title: 'Suite_title' }]
+     */
+    saveToCsv(data: any, headers: any): Promise<void>;
+    /**
+     * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+     * @param {Object} test - object which includes each test entry.
+     */
+    addTest(test: any): void;
+    /**
+     * @param {{ tests?: TestData[] }} runParams
+     * @returns {Promise<void>}
+     */
+    finishRun(runParams: {
+        tests?: TestData[];
+    }): Promise<void>;
+    toString(): string;
+}

package/lib/pipe/csv.js

@@ -13,8 +13,8 @@ const utils_js_1 = require("../utils/utils.js");
 const constants_js_1 = require("../constants.js");
 const debug = (0, debug_1.default)('@testomatio/reporter:pipe:csv');
 /**
- * @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 CsvPipe
  * @implements {Pipe}
  */

package/lib/pipe/debug.d.ts

@@ -0,0 +1,29 @@
+export class DebugPipe {
+    constructor(params: any, store: any);
+    params: any;
+    store: any;
+    isEnabled: boolean;
+    batch: {
+        isEnabled: any;
+        intervalFunction: any;
+        intervalTime: number;
+        tests: any[];
+        batchIndex: number;
+    };
+    logFilePath: string;
+    testomatioEnvVars: {};
+    batchUpload(): Promise<void>;
+    /**
+     * 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: any): Promise<void>;
+    lastActionTimestamp: number;
+    prepareRun(opts: any): Promise<any[]>;
+    createRun(params?: {}): Promise<{}>;
+    addTest(data: any): Promise<void>;
+    finishRun(params: any): Promise<void>;
+    toString(): string;
+}

package/lib/pipe/debug.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugPipe = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const debug_1 = __importDefault(require("debug"));
+const constants_js_1 = require("../constants.js");
+const pretty_ms_1 = __importDefault(require("pretty-ms"));
+const debug = (0, debug_1.default)('@testomatio/reporter:pipe:debug');
+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_1.default.join(os_1.default.tmpdir(), `testomatio.debug.${Date.now()}.json`);
+            debug('Creating debug file:', this.logFilePath);
+            fs_1.default.writeFileSync(this.logFilePath, '');
+            console.log(constants_js_1.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: `+${(0, pretty_ms_1.default)(timePassedFromLastAction)}`, ...logData });
+        fs_1.default.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(constants_js_1.APP_PREFIX, '🪲. Debug Saved to', this.logFilePath);
+    }
+    toString() {
+        return 'Debug Reporter';
+    }
+}
+exports.DebugPipe = DebugPipe;
+
+module.exports.DebugPipe = DebugPipe;