@testomatio/reporter 2.6.4-beta.1 → 2.7.0

package/lib/adapter/codecept.js

@@ -115,7 +115,7 @@ function CodeceptReporter(config) {
     });
     // mark as failed all tests inside the failed hook
     event.dispatcher.on(event.hook.failed, hook => {
-        if (hook.name !== 'BeforeSuiteHook')
+        if (hook.name !== 'BeforeSuiteHook' && hook.name !== 'BeforeHook')
             return;
         const suite = hook.runnable.parent;
         if (!suite)

package/lib/adapter/mocha.js

@@ -19,6 +19,8 @@ function MochaReporter(runner, opts) {
     // let artifactStore;
     const apiKey = opts?.reporterOptions?.apiKey || config_js_1.config.TESTOMATIO;
     const client = new client_js_1.default({ apiKey });
+    // Track hook failures
+    const hookFailures = new Map();
     runner.on(EVENT_RUN_BEGIN, () => {
         client.createRun();
         // clear dir with artifacts/logs
@@ -27,7 +29,30 @@ function MochaReporter(runner, opts) {
     runner.on(EVENT_SUITE_BEGIN, async (suite) => {
         index_js_1.services.setContext(suite.fullTitle());
     });
-    runner.on(EVENT_SUITE_END, async () => {
+    runner.on(EVENT_SUITE_END, async (suite) => {
+        if (hookFailures.has(suite.fullTitle())) {
+            const { error, suiteTitle } = hookFailures.get(suite.fullTitle());
+            for (const test of suite.tests) {
+                if (test.state === 'pending' || !test.state) {
+                    const testId = (0, utils_js_1.getTestomatIdFromTestTitle)(test.title);
+                    const artifacts = index_js_1.services.artifacts.get(test.fullTitle());
+                    const keyValues = index_js_1.services.keyValues.get(test.fullTitle());
+                    const links = index_js_1.services.links.get(test.fullTitle());
+                    client.addTestRun(constants_js_1.STATUS.FAILED, {
+                        error,
+                        suite_title: suiteTitle || suite.title,
+                        file: suite.file,
+                        test_id: testId,
+                        title: test.title,
+                        code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
+                        time: 0,
+                        manuallyAttachedArtifacts: artifacts,
+                        meta: keyValues,
+                        links,
+                    });
+                }
+            }
+        }
         index_js_1.services.setContext(null);
     });
     runner.on(EVENT_TEST_BEGIN, async (test) => {
@@ -79,6 +104,14 @@ function MochaReporter(runner, opts) {
     runner.on(EVENT_TEST_FAIL, async (test, err) => {
         failures += 1;
         console.log(picocolors_1.default.bold(picocolors_1.default.red('✖')), test.fullTitle(), picocolors_1.default.gray(err.message));
+        const isHookFailure = test.title.includes('before each') || test.title.includes('after each');
+        if (isHookFailure && test.parent) {
+            hookFailures.set(test.parent.fullTitle(), {
+                error: err,
+                suiteTitle: getSuiteTitle(test),
+            });
+            return;
+        }
         const testId = (0, utils_js_1.getTestomatIdFromTestTitle)(test.title);
         const logs = getTestLogs(test);
         const artifacts = index_js_1.services.artifacts.get(test.fullTitle());

package/lib/adapter/webdriver.d.ts

@@ -4,15 +4,22 @@ declare class WebdriverReporter extends WDIOReporter {
     client: TestomatClient;
     _addTestPromises: any[];
     _isSynchronising: boolean;
+    hooksEnhancer: any;
+    /**
+     * Initialize the hooks enhancer
+     * @private
+     */
+    private _initializeHooksEnhancer;
     /**
      *
      * @param {RunnerStats} runData
      */
     onRunnerEnd(runData: RunnerStats): Promise<void>;
     onRunnerStart(): void;
+    onHookEnd(hook: any): void;
+    onSuiteEnd(suiteOrScenario: any): Promise<void>;
     onTestStart(test: any): void;
     onTestEnd(test: any): void;
-    onSuiteEnd(scerario: any): void;
     addTest(test: any): Promise<void>;
     /**
      * @param {import('../../types/types.js').WebdriverIOScenario} scenario

package/lib/adapter/webdriver.js

@@ -49,6 +49,11 @@ class WebdriverReporter extends reporter_1.default {
         options = Object.assign(options, { stdout: true });
         this._addTestPromises = [];
         this._isSynchronising = false;
+        // Optional hooks enhancer for beforeEach failure handling
+        this.hooksEnhancer = null;
+        if (options?.enableHooksEnhancer) {
+            this._initializeHooksEnhancer();
+        }
         // run is created by cli, if enabling the row below, it mat lead to multiple runs being created
         // thus, need to check if process.env.runId is set and/or add more checks to avoid creating multiple runs
         // this.client.createRun();
@@ -56,6 +61,27 @@ class WebdriverReporter extends reporter_1.default {
     get isSynchronised() {
         return this._isSynchronising === false;
     }
+    /**
+     * Initialize the hooks enhancer
+     * @private
+     */
+    async _initializeHooksEnhancer() {
+        try {
+            // Dynamic import to avoid hard dependency
+            // Resolve package path from the project's node_modules
+            const { createRequire } = await Promise.resolve().then(() => __importStar(require('module')));
+            const projectRequire = createRequire(process.cwd() + '/package.json');
+            // Import the hooks enhancer package
+            const packagePath = projectRequire.resolve('@testomatio/webdriver-hooks-enhancer');
+            const hooksEnhancerModule = await Promise.resolve(`${packagePath}`).then(s => __importStar(require(s)));
+            const { createHooksEnhancer } = hooksEnhancerModule;
+            this.hooksEnhancer = createHooksEnhancer(this);
+            console.log('[TESTOMATIO] WebdriverIO Hooks Enhancer enabled');
+        }
+        catch (error) {
+            console.warn('[TESTOMATIO] Could not enable WebdriverIO Hooks Enhancer.', 'Install @testomatio/webdriver-hooks-enhancer to use this feature:', error.message);
+        }
+    }
     /**
      *
      * @param {RunnerStats} runData
@@ -72,6 +98,22 @@ class WebdriverReporter extends reporter_1.default {
         // clear dir with artifacts/logs
         utils_js_1.fileSystem.clearDir(constants_js_1.TESTOMAT_TMP_STORAGE_DIR);
     }
+    onHookEnd(hook) {
+        // Hooks enhancer will handle this if enabled
+        if (this.hooksEnhancer) {
+            this.hooksEnhancer.trackHookFailure(hook);
+        }
+    }
+    async onSuiteEnd(suiteOrScenario) {
+        // Handle hook failures for regular suites using enhancer
+        if (this.hooksEnhancer && suiteOrScenario.type !== 'scenario') {
+            await this.hooksEnhancer.handleSuiteEnd(suiteOrScenario, this.client, utils_js_1.getTestomatIdFromTestTitle);
+        }
+        // Handle BDD scenarios (cucumber)
+        if (suiteOrScenario.type === 'scenario') {
+            this._addTestPromises.push(this.addBddScenario(suiteOrScenario));
+        }
+    }
     onTestStart(test) {
         index_js_1.services.setContext(test.fullTitle);
     }
@@ -84,12 +126,6 @@ class WebdriverReporter extends reporter_1.default {
         test.logs = logs;
         this._addTestPromises.push(this.addTest(test));
     }
-    // wdio-cucumber does not trigger onTestEnd hook, thus, using this one
-    onSuiteEnd(scerario) {
-        if (scerario.type === 'scenario') {
-            this._addTestPromises.push(this.addBddScenario(scerario));
-        }
-    }
     async addTest(test) {
         if (!this.client)
             return;

package/lib/pipe/bitbucket.d.ts

@@ -17,6 +17,7 @@ export class BitbucketPipe {
     createRun(): Promise<void>;
     addTest(test: any): void;
     finishRun(runParams: any): Promise<void>;
+    sync(): Promise<void>;
     toString(): string;
     updateRun(): void;
 }

package/lib/pipe/bitbucket.js

@@ -198,6 +198,10 @@ class BitbucketPipe {
       Request data: ${body}`);
         }
     }
+    async sync() {
+        // BitbucketPipe doesn't buffer tests, so sync is a no-op
+        // Reserved for future use if needed
+    }
     toString() {
         return 'Bitbucket Reporter';
     }

package/lib/pipe/coverage.d.ts

@@ -25,6 +25,7 @@ declare class CoveragePipe {
     createRun(): Promise<void>;
     updateRun(): void;
     finishRun(runParams: any): Promise<void>;
+    sync(): Promise<void>;
     toString(): string;
     /**
      * Retrieves the list of files changed in the current Git working directory

package/lib/pipe/coverage.js

@@ -162,6 +162,10 @@ class CoveragePipe {
     async createRun() { }
     updateRun() { }
     async finishRun(runParams) { }
+    async sync() {
+        // CoveragePipe doesn't buffer tests, so sync is a no-op
+        // Reserved for future use if needed
+    }
     toString() {
         return 'Coverage Reporter';
     }

package/lib/pipe/csv.d.ts

@@ -43,5 +43,6 @@ declare class CsvPipe implements Pipe {
     finishRun(runParams: {
         tests?: TestData[];
     }): Promise<void>;
+    sync(): Promise<void>;
     toString(): string;
 }

package/lib/pipe/csv.js

@@ -113,6 +113,9 @@ class CsvPipe {
             return;
         if (runParams.tests)
             runParams.tests.forEach(t => this.addTest(t));
+        await this.sync();
+    }
+    async sync() {
         // Save results based on the default headers
         if (this.isEnabled) {
             await this.saveToCsv(this.results, constants_js_1.CSV_HEADERS);

package/lib/pipe/debug.d.ts

@@ -25,5 +25,6 @@ export class DebugPipe {
     createRun(params?: {}): Promise<{}>;
     addTest(data: any): Promise<void>;
     finishRun(params: any): Promise<void>;
+    sync(): Promise<void>;
     toString(): string;
 }

package/lib/pipe/debug.js

@@ -114,12 +114,17 @@ class DebugPipe {
     async finishRun(params) {
         if (!this.isEnabled)
             return;
-        await this.batchUpload();
+        await this.sync();
         if (this.batch.intervalFunction)
             clearInterval(this.batch.intervalFunction);
         this.logToFile({ action: 'finishRun', params });
         console.log(constants_js_1.APP_PREFIX, '🪲 Debug Saved to', this.logFilePath);
     }
+    async sync() {
+        if (!this.isEnabled)
+            return;
+        await this.batchUpload();
+    }
     toString() {
         return 'Debug Reporter';
     }

package/lib/pipe/github.d.ts

@@ -26,5 +26,6 @@ declare class GitHubPipe implements Pipe {
     octokit: import("@octokit/core").Octokit & import("@octokit/plugin-rest-endpoint-methods/dist-types/generated/method-types.js").RestEndpointMethods & import("@octokit/plugin-rest-endpoint-methods").Api & {
         paginate: import("@octokit/plugin-paginate-rest").PaginateInterface;
     };
+    sync(): Promise<void>;
     toString(): string;
 }

package/lib/pipe/github.js

@@ -203,6 +203,10 @@ class GitHubPipe {
             console.log(constants_js_1.APP_PREFIX, picocolors_1.default.yellow('GitHub'), `Couldn't create GitHub report ${err}`);
         }
     }
+    async sync() {
+        // GitHubPipe doesn't buffer tests, so sync is a no-op
+        // Reserved for future use if needed
+    }
     toString() {
         return 'GitHub Reporter';
     }

package/lib/pipe/gitlab.d.ts

@@ -19,6 +19,7 @@ declare class GitLabPipe {
     createRun(): Promise<void>;
     addTest(test: any): void;
     finishRun(runParams: any): Promise<void>;
+    sync(): Promise<void>;
     toString(): string;
     updateRun(): void;
 }

package/lib/pipe/gitlab.js

@@ -155,6 +155,10 @@ class GitLabPipe {
       Request data: ${body}`);
         }
     }
+    async sync() {
+        // GitLabPipe doesn't buffer tests, so sync is a no-op
+        // Reserved for future use if needed
+    }
     toString() {
         return 'GitLab Reporter';
     }

package/lib/pipe/html.d.ts

@@ -29,6 +29,7 @@ declare class HtmlPipe {
      * @returns {void} - This function does not return anything.
      */
     buildReport(opts: object): void;
+    sync(): Promise<void>;
     toString(): string;
     #private;
 }

package/lib/pipe/html.js

@@ -321,6 +321,10 @@ class HtmlPipe {
             return Object.keys(obj).length;
         });
     }
+    async sync() {
+        // HtmlPipe doesn't buffer tests, so sync is a no-op
+        // Reserved for future use if needed
+    }
     toString() {
         return 'HTML Reporter';
     }

package/lib/pipe/testomatio.d.ts

@@ -60,6 +60,11 @@ declare class TestomatioPipe implements Pipe {
      * Adds a test to the batch uploader (or reports a single test if batch uploading is disabled)
      */
     addTest(data: any): Promise<void | import("gaxios").GaxiosResponse<any>>;
+    /**
+     * Syncs / flushes buffered tests by uploading them as a batch
+     * This is used to manually trigger batch upload (e.g., after all tests are added)
+     */
+    sync(): Promise<void>;
     /**
      * @param {import('../../types/types.js').RunData} params
      * @returns

package/lib/pipe/testomatio.js

@@ -264,6 +264,8 @@ class TestomatioPipe {
             const errorText = err.response?.data?.message || err.message;
             debug('Error creating run', err);
             console.log(errorText || err);
+            if (err.response?.status === 403)
+                this.#disablePipe();
             if (!this.apiKey)
                 console.error('Testomat.io API key is not set');
             if (!this.apiKey?.startsWith('tstmt'))
@@ -312,6 +314,8 @@ class TestomatioPipe {
             maxContentLength: Infinity,
         })
             .catch(err => {
+            if (err.response?.status === 403)
+                this.#disablePipe();
             this.requestFailures++;
             this.notReportedTestsCount++;
             if (err.response) {
@@ -363,6 +367,8 @@ class TestomatioPipe {
             maxContentLength: Infinity,
         })
             .catch(err => {
+            if (err.response?.status === 403)
+                this.#disablePipe();
             this.requestFailures++;
             this.notReportedTestsCount += testsToSend.length;
             if (err.response) {
@@ -398,6 +404,15 @@ class TestomatioPipe {
         // return promise to be able to wait for it
         return uploading;
     }
+    /**
+     * Syncs / flushes buffered tests by uploading them as a batch
+     * This is used to manually trigger batch upload (e.g., after all tests are added)
+     */
+    async sync() {
+        if (!this.isEnabled)
+            return;
+        await this.#batchUpload();
+    }
     /**
      * @param {import('../../types/types.js').RunData} params
      * @returns
@@ -472,6 +487,17 @@ class TestomatioPipe {
         }
         debug('Run finished');
     }
+    #disablePipe() {
+        this.isEnabled = false;
+        this.apiKey = null;
+        // clear interval function, otherwise the proccess will continue indefinitely
+        if (this.batch.intervalFunction) {
+            clearInterval(this.batch.intervalFunction);
+            this.batch.intervalFunction = null;
+            this.batch.isEnabled = false;
+        }
+        this.batch.tests = [];
+    }
     #logFailedResponse(error) {
         let responseBody = stringify(error.response?.data ?? error.response ?? error, { pretty: true });
         if (!responseBody)

package/lib/xmlReader.d.ts

@@ -93,6 +93,7 @@ declare class XmlReader {
     pipes: any;
     uploadData(): Promise<any[]>;
     _finishRun(): Promise<any[]>;
+    #private;
 }
 import { XMLParser } from 'fast-xml-parser';
 import { S3Uploader } from './uploader.js';

package/lib/xmlReader.js

@@ -452,6 +452,43 @@ class XmlReader {
         this.uploader.checkEnabled();
         return run;
     }
+    /**
+     * Calculate the approximate size of data in bytes (JSON stringified length)
+     * @param {Object} data - Data to measure
+     * @returns {number} Size in bytes
+     */
+    #getObjectSize(data) {
+        const body = JSON.stringify(data);
+        return new TextEncoder().encode(body).length;
+    }
+    /**
+     * Split tests array into chunks based on data size
+     * @param {Array} tests - Array of tests to split
+     * @returns {Array<Array>} Array of test chunks
+     */
+    #splitTestsIntoChunks(tests) {
+        const maxSizeBytes = 1 * 1024 * 1024;
+        const chunks = [];
+        let currentChunk = [];
+        let currentChunkSize = 0;
+        for (const test of tests) {
+            const testSize = this.#getObjectSize(test);
+            const wouldExceedSize = currentChunkSize + testSize > maxSizeBytes;
+            if (wouldExceedSize) {
+                if (currentChunk.length > 0) {
+                    chunks.push(currentChunk);
+                }
+                currentChunk = [];
+                currentChunkSize = 0;
+            }
+            currentChunk.push(test);
+            currentChunkSize += testSize;
+        }
+        if (currentChunk.length > 0) {
+            chunks.push(currentChunk);
+        }
+        return chunks;
+    }
     async uploadData() {
         await this.uploadArtifacts();
         this.calculateStats();
@@ -459,16 +496,51 @@ class XmlReader {
         this.fetchSourceCode();
         this.formatErrors();
         this.formatTests();
-        const dataString = {
-            ...this.stats,
+        this.pipes = this.pipes || (await this.pipesPromise);
+        // Create run before uploading tests to ensure runId is set
+        await this.createRun();
+        if (!this.tests || !Array.isArray(this.tests) || this.tests.length === 0) {
+            debug('No tests to upload, finishing run');
+            const finishData = {
+                api_key: this.requestParams.apiKey,
+                status: 'finished',
+                duration: this.stats.duration,
+                detach: this.requestParams.detach,
+            };
+            return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
+        }
+        const testChunks = this.#splitTestsIntoChunks(this.tests);
+        const totalChunks = testChunks.length;
+        const totalTests = this.tests.length;
+        debug(`Split ${totalTests} tests into ${totalChunks} chunks (max 1MB per chunk)`);
+        let uploadedTests = 0;
+        for (let i = 0; i < testChunks.length; i++) {
+            const chunk = testChunks[i];
+            const chunkNum = i + 1;
+            if (totalChunks > 1) {
+                debug(`Uploading chunk ${chunkNum}/${totalChunks} (${chunk.length} tests)`);
+            }
+            for (const test of chunk) {
+                await Promise.all(this.pipes.map(p => p.addTest(test)));
+            }
+            await Promise.all(this.pipes.map(p => p.sync()));
+            uploadedTests += chunk.length;
+            debug(`Uploaded ${uploadedTests}/${totalTests} tests`);
+        }
+        if (totalChunks > 1) {
+            console.log(constants_js_1.APP_PREFIX, `✅ Successfully uploaded ${uploadedTests} tests in ${totalChunks} chunks`);
+        }
+        else {
+            console.log(constants_js_1.APP_PREFIX, `✅ Successfully uploaded ${uploadedTests} tests`);
+        }
+        const finishData = {
             api_key: this.requestParams.apiKey,
             status: 'finished',
             duration: this.stats.duration,
-            tests: this.tests,
+            detach: this.requestParams.detach,
         };
-        debug('Uploading data', dataString);
-        this.pipes = this.pipes || (await this.pipesPromise);
-        return Promise.all(this.pipes.map(p => p.finishRun(dataString)));
+        debug('Finishing run with status:', finishData.status);
+        return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
     }
     async _finishRun() {
         this.pipes = this.pipes || (await this.pipesPromise);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "2.6.4-beta.1",
+  "version": "2.7.0",
   "description": "Testomatio Reporter Client",
   "engines": {
     "node": ">=18"
@@ -37,7 +37,7 @@
     "json-cycle": "^1.3.0",
     "lodash.memoize": "^4.1.2",
     "lodash.merge": "^4.6.2",
-    "minimatch": "^9.0.3",
+    "minimatch": "^10.2.4",
     "picocolors": "^1.0.1",
     "pretty-ms": "^7.0.1",
     "promise-retry": "^2.0.1",

package/src/adapter/codecept.js

@@ -133,7 +133,7 @@ function CodeceptReporter(config) {
 
   // mark as failed all tests inside the failed hook
   event.dispatcher.on(event.hook.failed, hook => {
-    if (hook.name !== 'BeforeSuiteHook') return;
+    if (hook.name !== 'BeforeSuiteHook' && hook.name !== 'BeforeHook') return;
     const suite = hook.runnable.parent;
 
     if (!suite) return;

package/src/adapter/mocha.js

@@ -29,6 +29,9 @@ function MochaReporter(runner, opts) {
 
   const client = new TestomatClient({ apiKey });
 
+  // Track hook failures
+  const hookFailures = new Map();
+
   runner.on(EVENT_RUN_BEGIN, () => {
     client.createRun();
 
@@ -40,7 +43,33 @@ function MochaReporter(runner, opts) {
     services.setContext(suite.fullTitle());
   });
 
-  runner.on(EVENT_SUITE_END, async () => {
+  runner.on(EVENT_SUITE_END, async suite => {
+    if (hookFailures.has(suite.fullTitle())) {
+      const { error, suiteTitle } = hookFailures.get(suite.fullTitle());
+
+      for (const test of suite.tests) {
+        if (test.state === 'pending' || !test.state) {
+          const testId = getTestomatIdFromTestTitle(test.title);
+          const artifacts = services.artifacts.get(test.fullTitle());
+          const keyValues = services.keyValues.get(test.fullTitle());
+          const links = services.links.get(test.fullTitle());
+
+          client.addTestRun(STATUS.FAILED, {
+            error,
+            suite_title: suiteTitle || suite.title,
+            file: suite.file,
+            test_id: testId,
+            title: test.title,
+            code: process.env.TESTOMATIO_UPDATE_CODE ? test.body.toString() : '',
+            time: 0,
+            manuallyAttachedArtifacts: artifacts,
+            meta: keyValues,
+            links,
+          });
+        }
+      }
+    }
+
     services.setContext(null);
   });
 
@@ -101,6 +130,17 @@ function MochaReporter(runner, opts) {
   runner.on(EVENT_TEST_FAIL, async (test, err) => {
     failures += 1;
     console.log(pc.bold(pc.red('✖')), test.fullTitle(), pc.gray(err.message));
+
+    const isHookFailure = test.title.includes('before each') || test.title.includes('after each');
+
+    if (isHookFailure && test.parent) {
+      hookFailures.set(test.parent.fullTitle(), {
+        error: err,
+        suiteTitle: getSuiteTitle(test),
+      });
+      return;
+    }
+
     const testId = getTestomatIdFromTestTitle(test.title);
 
     const logs = getTestLogs(test);

package/src/adapter/webdriver.js

@@ -16,6 +16,12 @@ class WebdriverReporter extends WDIOReporter {
 
     this._isSynchronising = false;
 
+    // Optional hooks enhancer for beforeEach failure handling
+    this.hooksEnhancer = null;
+    if (options?.enableHooksEnhancer) {
+      this._initializeHooksEnhancer();
+    }
+
     // run is created by cli, if enabling the row below, it mat lead to multiple runs being created
     // thus, need to check if process.env.runId is set and/or add more checks to avoid creating multiple runs
     // this.client.createRun();
@@ -25,6 +31,32 @@ class WebdriverReporter extends WDIOReporter {
     return this._isSynchronising === false;
   }
 
+  /**
+   * Initialize the hooks enhancer
+   * @private
+   */
+  async _initializeHooksEnhancer() {
+    try {
+      // Dynamic import to avoid hard dependency
+      // Resolve package path from the project's node_modules
+      const { createRequire } = await import('module');
+      const projectRequire = createRequire(process.cwd() + '/package.json');
+      // Import the hooks enhancer package
+      const packagePath = projectRequire.resolve('@testomatio/webdriver-hooks-enhancer');
+      const hooksEnhancerModule = await import(packagePath);
+      const { createHooksEnhancer } = hooksEnhancerModule;
+      
+      this.hooksEnhancer = createHooksEnhancer(this);
+      console.log('[TESTOMATIO] WebdriverIO Hooks Enhancer enabled');
+    } catch (error) {
+      console.warn(
+        '[TESTOMATIO] Could not enable WebdriverIO Hooks Enhancer.',
+        'Install @testomatio/webdriver-hooks-enhancer to use this feature:',
+        error.message
+      );
+    }
+  }
+
   /**
    *
    * @param {RunnerStats} runData
@@ -46,6 +78,29 @@ class WebdriverReporter extends WDIOReporter {
     fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
   }
 
+  onHookEnd(hook) {
+    // Hooks enhancer will handle this if enabled
+    if (this.hooksEnhancer) {
+      this.hooksEnhancer.trackHookFailure(hook);
+    }
+  }
+
+  async onSuiteEnd(suiteOrScenario) {
+    // Handle hook failures for regular suites using enhancer
+    if (this.hooksEnhancer && suiteOrScenario.type !== 'scenario') {
+      await this.hooksEnhancer.handleSuiteEnd(
+        suiteOrScenario,
+        this.client,
+        getTestomatIdFromTestTitle
+      );
+    }
+
+    // Handle BDD scenarios (cucumber)
+    if (suiteOrScenario.type === 'scenario') {
+      this._addTestPromises.push(this.addBddScenario(suiteOrScenario));
+    }
+  }
+
   onTestStart(test) {
     services.setContext(test.fullTitle);
   }
@@ -62,13 +117,6 @@ class WebdriverReporter extends WDIOReporter {
     this._addTestPromises.push(this.addTest(test));
   }
 
-  // wdio-cucumber does not trigger onTestEnd hook, thus, using this one
-  onSuiteEnd(scerario) {
-    if (scerario.type === 'scenario') {
-      this._addTestPromises.push(this.addBddScenario(scerario));
-    }
-  }
-
   async addTest(test) {
     if (!this.client) return;
 

package/src/pipe/bitbucket.js

@@ -205,6 +205,11 @@ export class BitbucketPipe {
     }
   }
 
+  async sync() {
+    // BitbucketPipe doesn't buffer tests, so sync is a no-op
+    // Reserved for future use if needed
+  }
+
   toString() {
     return 'Bitbucket Reporter';
   }

package/src/pipe/coverage.js

@@ -192,6 +192,11 @@ class CoveragePipe { // or Changes for the future???
 
     async finishRun(runParams) {}
 
+    async sync() {
+        // CoveragePipe doesn't buffer tests, so sync is a no-op
+        // Reserved for future use if needed
+    }
+
     toString() {
         return 'Coverage Reporter';
     }

package/src/pipe/csv.js

@@ -125,6 +125,10 @@ class CsvPipe {
     if (!this.isEnabled) return;
 
     if (runParams.tests) runParams.tests.forEach(t => this.addTest(t));
+    await this.sync();
+  }
+
+  async sync() {
     // Save results based on the default headers
     if (this.isEnabled) {
       await this.saveToCsv(this.results, CSV_HEADERS);

package/src/pipe/debug.js

@@ -112,12 +112,17 @@ export class DebugPipe {
 
   async finishRun(params) {
     if (!this.isEnabled) return;
-    await this.batchUpload();
+    await this.sync();
     if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
     this.logToFile({ action: 'finishRun', params });
     console.log(APP_PREFIX, '🪲 Debug Saved to', this.logFilePath);
   }
 
+  async sync() {
+    if (!this.isEnabled) return;
+    await this.batchUpload();
+  }
+
   toString() {
     return 'Debug Reporter';
   }

package/src/pipe/github.js

@@ -197,6 +197,11 @@ class GitHubPipe {
     }
   }
 
+  async sync() {
+    // GitHubPipe doesn't buffer tests, so sync is a no-op
+    // Reserved for future use if needed
+  }
+
   toString() {
     return 'GitHub Reporter';
   }

package/src/pipe/gitlab.js

@@ -195,6 +195,11 @@ class GitLabPipe {
     }
   }
 
+  async sync() {
+    // GitLabPipe doesn't buffer tests, so sync is a no-op
+    // Reserved for future use if needed
+  }
+
   toString() {
     return 'GitLab Reporter';
   }

package/src/pipe/html.js

@@ -402,6 +402,11 @@ class HtmlPipe {
     });
   }
 
+  async sync() {
+    // HtmlPipe doesn't buffer tests, so sync is a no-op
+    // Reserved for future use if needed
+  }
+
   toString() {
     return 'HTML Reporter';
   }

package/src/pipe/testomatio.js

@@ -294,6 +294,7 @@ class TestomatioPipe {
       const errorText = err.response?.data?.message || err.message;
       debug('Error creating run', err);
       console.log(errorText || err);
+      if (err.response?.status === 403) this.#disablePipe();
       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');
 
@@ -347,6 +348,7 @@ class TestomatioPipe {
         maxContentLength: Infinity,
       })
       .catch(err => {
+        if (err.response?.status === 403) this.#disablePipe();
         this.requestFailures++;
         this.notReportedTestsCount++;
         if (err.response) {
@@ -397,6 +399,7 @@ class TestomatioPipe {
         maxContentLength: Infinity,
       })
       .catch(err => {
+        if (err.response?.status === 403) this.#disablePipe();
         this.requestFailures++;
         this.notReportedTestsCount += testsToSend.length;
         if (err.response) {
@@ -434,6 +437,15 @@ class TestomatioPipe {
     return uploading;
   }
 
+  /**
+   * Syncs / flushes buffered tests by uploading them as a batch
+   * This is used to manually trigger batch upload (e.g., after all tests are added)
+   */
+  async sync() {
+    if (!this.isEnabled) return;
+    await this.#batchUpload();
+  }
+
   /**
    * @param {import('../../types/types.js').RunData} params
    * @returns
@@ -520,6 +532,19 @@ class TestomatioPipe {
     debug('Run finished');
   }
 
+  #disablePipe() {
+    this.isEnabled = false;
+    this.apiKey = null;
+
+    // clear interval function, otherwise the proccess will continue indefinitely
+    if (this.batch.intervalFunction) {
+      clearInterval(this.batch.intervalFunction);
+      this.batch.intervalFunction = null;
+      this.batch.isEnabled = false;
+    }              
+    this.batch.tests = [];
+  }
+
   #logFailedResponse(error) {
     let responseBody = stringify(error.response?.data ?? error.response ?? error, { pretty: true });
     if (!responseBody) responseBody = '<empty>';

package/src/xmlReader.js

@@ -529,6 +529,52 @@ class XmlReader {
     return run;
   }
 
+  /**
+   * Calculate the approximate size of data in bytes (JSON stringified length)
+   * @param {Object} data - Data to measure
+   * @returns {number} Size in bytes
+   */
+  #getObjectSize(data) {
+    const body = JSON.stringify(data);
+    return new TextEncoder().encode(body).length;
+  }
+
+  /**
+   * Split tests array into chunks based on data size
+   * @param {Array} tests - Array of tests to split
+   * @returns {Array<Array>} Array of test chunks
+   */
+  #splitTestsIntoChunks(tests) {
+    const maxSizeBytes = 1 * 1024 * 1024;
+
+    const chunks = [];
+    let currentChunk = [];
+    let currentChunkSize = 0;
+
+    for (const test of tests) {
+      const testSize = this.#getObjectSize(test);
+
+      const wouldExceedSize = currentChunkSize + testSize > maxSizeBytes;
+
+      if (wouldExceedSize) {
+        if (currentChunk.length > 0) {
+          chunks.push(currentChunk);
+        }
+        currentChunk = [];
+        currentChunkSize = 0;
+      }
+
+      currentChunk.push(test);
+      currentChunkSize += testSize;
+    }
+
+    if (currentChunk.length > 0) {
+      chunks.push(currentChunk);
+    }
+
+    return chunks;
+  }
+
   async uploadData() {
     await this.uploadArtifacts();
     this.calculateStats();
@@ -537,18 +583,63 @@ class XmlReader {
     this.formatErrors();
     this.formatTests();
 
-    const dataString = {
-      ...this.stats,
+    this.pipes = this.pipes || (await this.pipesPromise);
+
+    // Create run before uploading tests to ensure runId is set
+    await this.createRun();
+
+    if (!this.tests || !Array.isArray(this.tests) || this.tests.length === 0) {
+      debug('No tests to upload, finishing run');
+      const finishData = {
+        api_key: this.requestParams.apiKey,
+        status: 'finished',
+        duration: this.stats.duration,
+        detach: this.requestParams.detach,
+      };
+      return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
+    }
+
+    const testChunks = this.#splitTestsIntoChunks(this.tests);
+
+    const totalChunks = testChunks.length;
+    const totalTests = this.tests.length;
+
+    debug(`Split ${totalTests} tests into ${totalChunks} chunks (max 1MB per chunk)`);
+
+    let uploadedTests = 0;
+    for (let i = 0; i < testChunks.length; i++) {
+      const chunk = testChunks[i];
+      const chunkNum = i + 1;
+
+      if (totalChunks > 1) {
+        debug(`Uploading chunk ${chunkNum}/${totalChunks} (${chunk.length} tests)`);
+      }
+
+      for (const test of chunk) {
+        await Promise.all(this.pipes.map(p => p.addTest(test)));
+      }
+
+      await Promise.all(this.pipes.map(p => p.sync()));
+
+      uploadedTests += chunk.length;
+      debug(`Uploaded ${uploadedTests}/${totalTests} tests`);
+    }
+
+    if (totalChunks > 1) {
+      console.log(APP_PREFIX, `✅ Successfully uploaded ${uploadedTests} tests in ${totalChunks} chunks`);
+    } else {
+      console.log(APP_PREFIX, `✅ Successfully uploaded ${uploadedTests} tests`);
+    }
+
+    const finishData = {
       api_key: this.requestParams.apiKey,
       status: 'finished',
       duration: this.stats.duration,
-      tests: this.tests,
+      detach: this.requestParams.detach,
     };
 
-    debug('Uploading data', dataString);
-
-    this.pipes = this.pipes || (await this.pipesPromise);
-    return Promise.all(this.pipes.map(p => p.finishRun(dataString)));
+    debug('Finishing run with status:', finishData.status);
+    return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
   }
 
   async _finishRun() {

package/types/types.d.ts

@@ -290,6 +290,9 @@ export interface Pipe {
   /** adds a test to the current run */
   addTest(test: TestData): any;
 
+  /** syncs / flushes buffered data (e.g., uploads batched tests) */
+  sync(): Promise<void>;
+
   /** ends the run */
   finishRun(runParams: RunData): Promise<void>;