@testomatio/reporter 2.9.0 → 2.9.1-beta.2-allure-tms-link

package/README.md

@@ -76,6 +76,7 @@ npx testomatio-reporter <command> [options]
 | [TestCafe](./docs/frameworks.md#testcafe)       | [Detox](./docs/frameworks.md#detox)           | [Codeception](https://github.com/testomatio/php-reporter) |
 | [Newman (Postman)](./docs/frameworks.md#newman) | [JUnit](./docs/junit.md#junit)                | [NUnit](./docs/junit.md#nunit)                            |
 | [PyTest](./docs/junit.md#pytest)                | [PHPUnit](./docs/junit.md#phpunit)            | [Protractor](./docs/frameworks.md#protractor)             |
+| [Allure](./docs/allure.md)                      |                                               |                                                           |
 
 or **any [other via JUnit](./docs/junit.md)** report....
 
@@ -137,9 +138,10 @@ Bring this reporter on CI and never lose test results again!
   - [HTML report](./docs/pipes/html.md)
   - [Markdown report](./docs/pipes/markdown.md)
   - [Bitbucket](./docs/pipes/bitbucket.md)
-- 🔗 [Linking Tests](./docs/linking-tests.md)
-- 📓 [JUnit](./docs/junit.md)
+- 📓 [JUnit Reports](./docs/junit.md)
 - 🗄️ [Artifacts](./docs/artifacts.md)
+- 🔬 [Allure Reports](./docs/allure.md)
+- 🔗 [Linking Tests](./docs/linking-tests.md)
 - 🔂 [Workflows](./docs/workflows.md)
 - 🖊️ [Logger](./docs/logger.md)
 - 🪲 [Debug File Format](./docs/debug-file-format.md)

package/lib/allureReader.d.ts

@@ -0,0 +1,93 @@
+export default AllureReader;
+declare class AllureReader {
+    constructor(opts?: {});
+    requestParams: {
+        apiKey: any;
+        url: any;
+        title: string;
+        env: string;
+        group_title: string;
+        batchMode: "manual";
+    };
+    runId: any;
+    opts: {};
+    withPackage: any;
+    store: {};
+    pipesPromise: Promise<any[]>;
+    _tests: any[];
+    stats: {};
+    suites: {};
+    uploader: S3Uploader;
+    version: any;
+    set tests(value: any[]);
+    get tests(): any[];
+    createRun(): Promise<any[]>;
+    pipes: any;
+    parse(resultsPattern: any): {};
+    parseContainerFiles(containerFiles: any): void;
+    processAllureResult(result: any, resultsDir: any): {
+        rid: any;
+        title: any;
+        status: any;
+        suite_title: any;
+        file: string;
+        run_time: number;
+        steps: any;
+        message: any;
+        stack: any;
+        meta: {};
+        links: {
+            label: string;
+        }[];
+        artifacts: any[];
+        create: boolean;
+        overwrite: boolean;
+    };
+    mapStatus(status: any): any;
+    extractSuiteTitle(result: any): any;
+    stripNamespace(suiteName: any): any;
+    extractFile(result: any): string;
+    getFileExtension(result: any): any;
+    extractMeta(result: any): {};
+    extractLinks(result: any): {
+        label: string;
+    }[];
+    /**
+     * Extract a Testomat.io test id from Allure links so reported tests match
+     * existing cases instead of creating duplicates.
+     *
+     * Allure's `@TmsLink("T1a2b3c4d")` produces a link with `type: "tms"`. Some exporters
+     * omit the type but still point the link URL at a Testomat.io test page; both are
+     * accepted. The link `name` is used as the id (falling back to the last URL segment).
+     *
+     * @param {object} result - Parsed Allure result JSON
+     * @returns {string|null} Normalized test id, or null when no usable link exists
+     */
+    extractTestId(result: object): string | null;
+    /**
+     * Normalize a value into a Testomat.io test id.
+     *
+     * Testomat.io test ids are exactly **8 word characters**. The value may arrive bare
+     * (`1a2b3c4d`), or carrying the `T` / `@T` markers Testomat uses in code and titles
+     * (`T1a2b3c4d`, `@T1a2b3c4d`). The markers are removed only when doing so still leaves
+     * a valid 8-char id, so a real id that happens to start with `T` is preserved.
+     *
+     * Anything that does not resolve to a valid 8-char id — a numeric Allure TestOps id
+     * like `12345`, a JIRA key, a 6-digit TMS number — is rejected (returns null) so we
+     * never send an unmatchable id that would create duplicates.
+     *
+     * @param {string|number|null|undefined} value
+     * @returns {string|null} The bare 8-char id, or null when the value is not a valid id
+     */
+    normalizeTestId(value: string | number | null | undefined): string | null;
+    convertSteps(steps: any, depth?: number): any;
+    calculateRunTime(item: any): number;
+    convertParameters(parameters: any): {};
+    combineRetryAttempts(attempts: any): any;
+    calculateStats(): {};
+    fetchSourceCode(): void;
+    getLanguage(): any;
+    uploadArtifacts(): Promise<void>;
+    uploadData(): Promise<any[]>;
+}
+import { S3Uploader } from './uploader.js';

package/lib/allureReader.js

@@ -0,0 +1,547 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const fs_1 = __importDefault(require("fs"));
+const glob_1 = require("glob");
+const constants_js_1 = require("./constants.js");
+const crypto_1 = require("crypto");
+const url_1 = require("url");
+const config_js_1 = require("./config.js");
+const uploader_js_1 = require("./uploader.js");
+const index_js_1 = require("./pipe/index.js");
+const pipe_utils_js_1 = require("./utils/pipe_utils.js");
+const utils_js_1 = require("./utils/utils.js");
+const index_js_2 = __importDefault(require("./junit-adapter/index.js"));
+// @ts-ignore
+const debug = (0, debug_1.default)('@testomatio/reporter:allure');
+const TESTOMATIO_URL = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+const { TESTOMATIO_RUNGROUP_TITLE, TESTOMATIO_SUITE, TESTOMATIO_TITLE, TESTOMATIO_ENV, TESTOMATIO_RUN } = process.env;
+class AllureReader {
+    constructor(opts = {}) {
+        this.requestParams = {
+            apiKey: opts.apiKey || config_js_1.config.TESTOMATIO,
+            url: opts.url || TESTOMATIO_URL,
+            title: TESTOMATIO_TITLE,
+            env: TESTOMATIO_ENV,
+            group_title: TESTOMATIO_RUNGROUP_TITLE,
+            // Buffer tests and flush them manually in size-limited chunks, exactly like XmlReader.
+            // No setInterval auto-upload means each test is sent exactly once (no double-send).
+            batchMode: constants_js_1.BATCH_MODE.MANUAL,
+        };
+        this.runId = opts.runId || TESTOMATIO_RUN;
+        this.opts = opts || {};
+        this.withPackage = opts.withPackage || false;
+        this.store = {};
+        this.pipesPromise = (0, index_js_1.pipesFactory)(opts, this.store);
+        this._tests = [];
+        this.stats = {};
+        this.suites = {};
+        this.uploader = new uploader_js_1.S3Uploader();
+        // Allure results already contain steps and stack traces for all tests,
+        // so enable passing them for passed tests by default
+        if (!process.env.TESTOMATIO_STACK_PASSED) {
+            process.env.TESTOMATIO_STACK_PASSED = '1';
+        }
+        if (!process.env.TESTOMATIO_STEPS_PASSED) {
+            process.env.TESTOMATIO_STEPS_PASSED = '1';
+        }
+        const packageJsonPath = path_1.default.resolve(__dirname, '..', 'package.json');
+        this.version = JSON.parse(fs_1.default.readFileSync(packageJsonPath).toString()).version;
+        console.log(constants_js_1.APP_PREFIX, `Testomatio Reporter v${this.version}`);
+    }
+    get tests() {
+        return this._tests;
+    }
+    set tests(value) {
+        this._tests = value;
+    }
+    async createRun() {
+        const runParams = {
+            api_key: this.requestParams.apiKey,
+            title: this.requestParams.title,
+            env: this.requestParams.env,
+            group_title: this.requestParams.group_title,
+            batchMode: this.requestParams.batchMode,
+        };
+        debug('Run', runParams);
+        this.pipes = this.pipes || (await this.pipesPromise);
+        const run = await Promise.all(this.pipes.map(p => p.createRun(runParams)));
+        this.uploader.checkEnabled();
+        return run;
+    }
+    parse(resultsPattern) {
+        this._tests = [];
+        let pattern = resultsPattern;
+        // Auto-append wildcard if pattern refers to a directory (like XML command does)
+        if (!pattern.endsWith('.json') && !pattern.includes('*')) {
+            if (pattern.endsWith('/') || (fs_1.default.existsSync(pattern) && fs_1.default.statSync(pattern).isDirectory())) {
+                pattern = pattern.replace(/\/+$/, '') + '/*-result.json';
+            }
+            else {
+                pattern += '*-result.json';
+            }
+        }
+        const resultsDir = path_1.default.dirname(pattern);
+        console.log(constants_js_1.APP_PREFIX, `Scanning for Allure results in: ${resultsDir}`);
+        console.log(constants_js_1.APP_PREFIX, `Using pattern: ${pattern}`);
+        const resultFiles = glob_1.glob.sync(pattern);
+        const containerFiles = glob_1.glob.sync(pattern.replace('*-result.json', '*-container.json'));
+        if (resultFiles.length === 0 && containerFiles.length === 0) {
+            throw new Error(`No Allure result files found matching pattern: ${pattern}`);
+        }
+        console.log(constants_js_1.APP_PREFIX, `Found ${resultFiles.length} result files and ${containerFiles.length} container files`);
+        this.parseContainerFiles(containerFiles);
+        // Store all tests temporarily for deduplication by historyId
+        const allTests = [];
+        for (const file of resultFiles) {
+            const fullPath = file;
+            const fileDir = path_1.default.dirname(file);
+            try {
+                const resultData = JSON.parse(fs_1.default.readFileSync(fullPath, 'utf8'));
+                const test = this.processAllureResult(resultData, fileDir);
+                if (test) {
+                    test._historyId = resultData.historyId;
+                    test._stop = resultData.stop || 0;
+                    allTests.push(test);
+                }
+            }
+            catch (err) {
+                console.warn(constants_js_1.APP_PREFIX, `Failed to parse ${file}:`, err.message);
+                debug('Parse error:', err);
+            }
+        }
+        const attemptsMap = new Map();
+        for (const test of allTests) {
+            const historyId = test._historyId || test.rid;
+            if (!attemptsMap.has(historyId)) {
+                attemptsMap.set(historyId, []);
+            }
+            attemptsMap.get(historyId).push(test);
+        }
+        const uniqueTestsMap = new Map();
+        for (const [historyId, attempts] of attemptsMap) {
+            uniqueTestsMap.set(historyId, this.combineRetryAttempts(attempts));
+        }
+        // Convert map to array and clean up internal fields
+        this._tests = Array.from(uniqueTestsMap.values()).map(t => {
+            delete t._historyId;
+            delete t._stop;
+            return t;
+        });
+        console.log(constants_js_1.APP_PREFIX, `Processed ${this._tests.length} unique tests (from ${allTests.length} result files)`);
+        return this.calculateStats();
+    }
+    parseContainerFiles(containerFiles) {
+        for (const file of containerFiles) {
+            try {
+                const data = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+                if (data.name && data.children) {
+                    data.children.forEach(uuid => {
+                        this.suites[uuid] = data.name;
+                    });
+                }
+            }
+            catch (err) {
+                debug('Failed to parse container file:', file, err.message);
+            }
+        }
+        debug('Parsed suites:', this.suites);
+    }
+    processAllureResult(result, resultsDir) {
+        const test = {
+            rid: result.uuid || (0, crypto_1.randomUUID)(),
+            title: result.name || 'Unknown test',
+            status: this.mapStatus(result.status),
+            suite_title: this.extractSuiteTitle(result),
+            file: this.extractFile(result),
+            run_time: this.calculateRunTime(result),
+            steps: this.convertSteps(result.steps || []),
+            message: result.statusDetails?.message || '',
+            stack: result.statusDetails?.trace || '',
+            meta: this.extractMeta(result),
+            links: this.extractLinks(result),
+            artifacts: [],
+            create: true,
+            overwrite: true,
+        };
+        // Use the @TmsLink / Testomat.io link as the test id so reported tests MATCH
+        // existing cases instead of creating duplicates on every run.
+        const testId = this.extractTestId(result);
+        if (testId) {
+            test.test_id = testId;
+        }
+        // Add description if present
+        if (result.description) {
+            test.description = result.description;
+        }
+        if (result.parameters && result.parameters.length > 0) {
+            test.example = this.convertParameters(result.parameters);
+        }
+        if (result.attachments && result.attachments.length > 0) {
+            const attachments = result.attachments
+                .map(att => {
+                const fullPath = path_1.default.join(resultsDir, att.source);
+                if (fs_1.default.existsSync(fullPath)) {
+                    return fullPath;
+                }
+                debug('Attachment file not found:', fullPath);
+                return null;
+            })
+                .filter(Boolean);
+            if (attachments.length > 0) {
+                test.files = attachments;
+            }
+        }
+        return test;
+    }
+    mapStatus(status) {
+        const statusMap = {
+            passed: 'passed',
+            failed: 'failed',
+            broken: 'failed',
+            skipped: 'skipped',
+            pending: 'skipped',
+        };
+        return statusMap[status] || 'failed';
+    }
+    extractSuiteTitle(result) {
+        const labels = result.labels || [];
+        // Only use suite label for suite_title
+        // Epic and Feature are sent as separate labels in meta
+        const suiteLabel = labels.find(l => l.name === 'suite')?.value;
+        if (suiteLabel) {
+            return this.stripNamespace(suiteLabel);
+        }
+        // Fallback to parentSuite or subSuite if no suite label
+        const parentSuite = labels.find(l => l.name === 'parentSuite')?.value;
+        const subSuite = labels.find(l => l.name === 'subSuite')?.value;
+        if (parentSuite && subSuite) {
+            return `${parentSuite} / ${subSuite}`;
+        }
+        if (parentSuite)
+            return parentSuite;
+        if (subSuite)
+            return subSuite;
+        return 'Default Suite';
+    }
+    stripNamespace(suiteName) {
+        if (suiteName && suiteName.includes('.')) {
+            return suiteName.split('.').pop();
+        }
+        return suiteName;
+    }
+    extractFile(result) {
+        const labels = result.labels || [];
+        const packageLabel = labels.find(l => l.name === 'package')?.value;
+        const testClassLabel = labels.find(l => l.name === 'testClass')?.value;
+        if (!packageLabel) {
+            return null;
+        }
+        const ext = this.getFileExtension(result);
+        let className;
+        if (testClassLabel) {
+            className = testClassLabel.split('.').pop();
+        }
+        else if (result.fullName) {
+            const fullNameParts = result.fullName.split('.');
+            className = fullNameParts[fullNameParts.length - 2] || fullNameParts[fullNameParts.length - 1];
+        }
+        else {
+            return null;
+        }
+        if (this.withPackage) {
+            const parts = packageLabel.split('.');
+            return `${parts.join('/')}/${className}.${ext}`;
+        }
+        return `${className}.${ext}`;
+    }
+    getFileExtension(result) {
+        const labels = result.labels || [];
+        const languageLabel = labels.find(l => l.name === 'language')?.value;
+        const extMap = {
+            java: 'java',
+            kotlin: 'kt',
+            javascript: 'js',
+            typescript: 'ts',
+            python: 'py',
+            ruby: 'rb',
+            'c#': 'cs',
+            php: 'php',
+        };
+        return extMap[languageLabel?.toLowerCase()] || 'java';
+    }
+    extractMeta(result) {
+        const labels = result.labels || [];
+        const excludedLabels = [
+            'suite', 'package', 'parentSuite', 'subSuite',
+            'testClass', 'testMethod', 'epic', 'feature',
+        ];
+        const meta = {};
+        labels.forEach(label => {
+            if (!excludedLabels.includes(label.name)) {
+                meta[label.name] = label.value;
+            }
+        });
+        return meta;
+    }
+    extractLinks(result) {
+        const labels = result.labels || [];
+        const links = [];
+        const epicLabel = labels.find(l => l.name === 'epic');
+        const featureLabel = labels.find(l => l.name === 'feature');
+        if (epicLabel?.value) {
+            links.push({ label: `epic:${epicLabel.value}` });
+        }
+        if (featureLabel?.value) {
+            links.push({ label: `feature:${featureLabel.value}` });
+        }
+        return links.length > 0 ? links : undefined;
+    }
+    /**
+     * Extract a Testomat.io test id from Allure links so reported tests match
+     * existing cases instead of creating duplicates.
+     *
+     * Allure's `@TmsLink("T1a2b3c4d")` produces a link with `type: "tms"`. Some exporters
+     * omit the type but still point the link URL at a Testomat.io test page; both are
+     * accepted. The link `name` is used as the id (falling back to the last URL segment).
+     *
+     * @param {object} result - Parsed Allure result JSON
+     * @returns {string|null} Normalized test id, or null when no usable link exists
+     */
+    extractTestId(result) {
+        const links = result.links || [];
+        if (!links.length)
+            return null;
+        const isTmsLink = l => typeof l?.type === 'string' && l.type.toLowerCase() === 'tms';
+        const isTestomatioLink = l => typeof l?.url === 'string' && /testomat\.io\/[^\s]*\/test\//i.test(l.url);
+        const link = links.find(isTmsLink) || links.find(isTestomatioLink);
+        if (!link)
+            return null;
+        // Prefer the explicit link name; fall back to the id segment of a Testomat.io URL.
+        let id = this.normalizeTestId(link.name);
+        if (!id && typeof link.url === 'string') {
+            const fromUrl = link.url.match(/\/test\/([\w\d]{8})(?=$|[/?#])/i);
+            if (fromUrl)
+                id = fromUrl[1];
+        }
+        return id;
+    }
+    /**
+     * Normalize a value into a Testomat.io test id.
+     *
+     * Testomat.io test ids are exactly **8 word characters**. The value may arrive bare
+     * (`1a2b3c4d`), or carrying the `T` / `@T` markers Testomat uses in code and titles
+     * (`T1a2b3c4d`, `@T1a2b3c4d`). The markers are removed only when doing so still leaves
+     * a valid 8-char id, so a real id that happens to start with `T` is preserved.
+     *
+     * Anything that does not resolve to a valid 8-char id — a numeric Allure TestOps id
+     * like `12345`, a JIRA key, a 6-digit TMS number — is rejected (returns null) so we
+     * never send an unmatchable id that would create duplicates.
+     *
+     * @param {string|number|null|undefined} value
+     * @returns {string|null} The bare 8-char id, or null when the value is not a valid id
+     */
+    normalizeTestId(value) {
+        if (value === null || value === undefined)
+            return null;
+        const match = value.toString().trim().match(/^@?T?([\w\d]{8})$/);
+        return match ? match[1] : null;
+    }
+    convertSteps(steps, depth = 0) {
+        if (depth >= 10)
+            return null;
+        return steps
+            .map(step => {
+            const convertedStep = {
+                category: 'user',
+                title: step.name || step.title || 'Unknown step',
+                duration: this.calculateRunTime(step),
+                steps: this.convertSteps(step.steps || [], depth + 1),
+            };
+            if (convertedStep.steps && convertedStep.steps.length === 0) {
+                delete convertedStep.steps;
+            }
+            if (convertedStep.duration === 0) {
+                delete convertedStep.duration;
+            }
+            return convertedStep;
+        })
+            .filter(Boolean);
+    }
+    calculateRunTime(item) {
+        if (item.start && item.stop) {
+            const durationMs = item.stop - item.start;
+            return durationMs / 1000;
+        }
+        return null;
+    }
+    convertParameters(parameters) {
+        const example = {};
+        parameters.forEach(param => {
+            if (param.name) {
+                example[param.name] = param.value;
+            }
+        });
+        return example;
+    }
+    combineRetryAttempts(attempts) {
+        attempts.sort((a, b) => (a._stop || 0) - (b._stop || 0));
+        const finalTest = attempts[attempts.length - 1];
+        const retryCount = attempts.length - 1;
+        if (retryCount > 0) {
+            finalTest.retries = retryCount;
+        }
+        const failedAttempts = attempts.filter(t => t.status === 'failed');
+        if (failedAttempts.length === 0) {
+            return finalTest;
+        }
+        const failureMessages = [];
+        const failureStacks = [];
+        for (const failed of failedAttempts) {
+            const attemptNum = attempts.indexOf(failed) + 1;
+            if (failed.message) {
+                failureMessages.push(`[Attempt ${attemptNum}] ${failed.message}`);
+            }
+            if (failed.stack) {
+                failureStacks.push(`\n--- Attempt ${attemptNum} ---\n${failed.stack}`);
+            }
+        }
+        if (failureMessages.length > 0) {
+            finalTest.message = failureMessages.join('\n');
+        }
+        if (failureStacks.length > 0) {
+            finalTest.stack = failureStacks.join('\n');
+        }
+        if (finalTest.status === 'passed') {
+            finalTest.status = 'failed';
+            const retryMsg = `Test passed after ${failedAttempts.length} retries. Previous failures:\n`;
+            finalTest.message = retryMsg + finalTest.message;
+        }
+        return finalTest;
+    }
+    calculateStats() {
+        this.stats = {
+            create_tests: true,
+            tests_count: this._tests.length,
+            passed_count: 0,
+            failed_count: 0,
+            skipped_count: 0,
+            duration: 0,
+            status: 'passed',
+            tests: this._tests,
+        };
+        this._tests.forEach(t => {
+            if (t.status === 'passed')
+                this.stats.passed_count++;
+            if (t.status === 'failed')
+                this.stats.failed_count++;
+            if (t.status === 'skipped')
+                this.stats.skipped_count++;
+        });
+        this.stats.duration = this._tests.reduce((acc, t) => acc + (t.run_time || 0), 0);
+        if (this.stats.failed_count)
+            this.stats.status = 'failed';
+        debug('Stats:', this.stats);
+        return this.stats;
+    }
+    fetchSourceCode() {
+        const adapter = this.adapter || (0, index_js_2.default)(this.getLanguage(), this.opts);
+        this._tests.forEach(t => {
+            try {
+                let filePath = t.file;
+                if (adapter && adapter.getFilePath) {
+                    filePath = adapter.getFilePath(t);
+                }
+                if (!filePath)
+                    return;
+                if (!fs_1.default.existsSync(filePath)) {
+                    debug('Source file not found:', filePath);
+                    return;
+                }
+                const contents = fs_1.default.readFileSync(filePath).toString();
+                const code = (0, utils_js_1.fetchSourceCode)(contents, { ...t, lang: this.getLanguage() });
+                if (code) {
+                    t.code = code;
+                    debug('Fetched code for test %s', t.title);
+                }
+                // Don't override an id already taken from a @TmsLink — the link is the
+                // explicit, source-independent match key the client maintains.
+                const testId = (0, utils_js_1.fetchIdFromCode)(contents, { lang: this.getLanguage() });
+                if (testId && !t.test_id) {
+                    t.test_id = testId;
+                    debug('Fetched test id %s for test %s', testId, t.title);
+                }
+            }
+            catch (err) {
+                debug('Failed to fetch source code:', err.message);
+            }
+        });
+    }
+    getLanguage() {
+        if (this._tests.length === 0)
+            return null;
+        return this._tests[0].meta?.language || this.opts.lang;
+    }
+    async uploadArtifacts() {
+        for (const test of this._tests.filter(t => t.files && t.files.length > 0)) {
+            const runId = this.runId || this.store.runId || Date.now().toString();
+            const artifacts = await Promise.all(test.files.map(f => this.uploader.uploadFileByPath(f, [runId, test.rid, path_1.default.basename(f)])));
+            test.artifacts = artifacts.filter(a => a && a.link).map(a => a.link);
+            delete test.files;
+            if (test.artifacts.length > 0) {
+                console.log(constants_js_1.APP_PREFIX, `🗄️ Uploaded ${picocolors_1.default.bold(`${test.artifacts.length} artifacts`)} for test ${test.title}`);
+            }
+        }
+    }
+    async uploadData() {
+        await this.uploadArtifacts();
+        this.calculateStats();
+        this.fetchSourceCode();
+        this.pipes = this.pipes || (await this.pipesPromise);
+        const finishData = {
+            api_key: this.requestParams.apiKey,
+            status: 'finished',
+            duration: this.stats.duration,
+        };
+        if (!this._tests || !Array.isArray(this._tests) || this._tests.length === 0) {
+            debug('No tests to upload, finishing run');
+            return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
+        }
+        // Upload tests in size-limited chunks (max 1MB each), exactly like XmlReader.
+        // The testomatio pipe runs in MANUAL batch mode, so addTest only buffers tests and
+        // sync() flushes one batch request per chunk. There is no setInterval auto-upload,
+        // so each test is sent exactly once (no double-send) and requests stay under the limit.
+        const testChunks = (0, pipe_utils_js_1.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];
+            if (totalChunks > 1) {
+                debug(`Uploading chunk ${i + 1}/${totalChunks} (${chunk.length} tests)`);
+            }
+            // Buffer each test in the chunk, then flush the whole chunk as a single batch
+            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`);
+        }
+        debug('Uploaded %d tests, finishing run', this._tests.length);
+        return Promise.all(this.pipes.map(p => p.finishRun(finishData)));
+    }
+}
+module.exports = AllureReader;