@testomatio/reporter 2.9.1 → 2.9.2-beta.1-allure-retries

package/lib/allureReader.js

@@ -0,0 +1,601 @@
+"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';
+    }
+    /**
+     * Map an Allure step status to the Testomat.io Step status enum
+     * (`passed | failed | none | custom`, see testomat-api-definition.yml).
+     *
+     * Allure marks a step `broken` when it threw an unexpected error — that is a
+     * failure for reporting purposes, matching how `mapStatus` treats tests.
+     * `skipped` and anything unknown/absent become `none` (the neutral value),
+     * since the step enum has no `skipped`.
+     *
+     * @param {string} status - Allure step status
+     * @returns {'passed'|'failed'|'none'} Testomat.io step status
+     */
+    mapStepStatus(status) {
+        const statusMap = {
+            passed: 'passed',
+            failed: 'failed',
+            broken: 'failed',
+            skipped: 'none',
+            pending: 'none',
+        };
+        return statusMap[status] || 'none';
+    }
+    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',
+                status: this.mapStepStatus(step.status),
+                duration: this.calculateRunTime(step),
+                steps: this.convertSteps(step.steps || [], depth + 1),
+            };
+            // Attach the failure description (error message + trace with the failing
+            // code line) straight onto the failed step. Testomat.io renders a step's
+            // `error` inline in the step tree, so the failure shows up on the exact
+            // step that broke instead of only at the test level.
+            const error = this.extractStepError(step);
+            if (error) {
+                convertedStep.error = error;
+            }
+            if (convertedStep.steps && convertedStep.steps.length === 0) {
+                delete convertedStep.steps;
+            }
+            if (convertedStep.duration === 0) {
+                delete convertedStep.duration;
+            }
+            return convertedStep;
+        })
+            .filter(Boolean);
+    }
+    /**
+     * Build the `error` payload for a failed step from its Allure `statusDetails`.
+     *
+     * Allure stores the failure message and stack trace (which includes the failing
+     * source line) in `statusDetails` on the step itself. We only surface it for
+     * failed/broken steps — passing or skipped steps carry no error. Returns null
+     * when there is no usable failure information so the field is omitted entirely.
+     *
+     * @param {object} step - Allure step
+     * @returns {{message: string, stack: string}|null}
+     */
+    extractStepError(step) {
+        if (this.mapStepStatus(step.status) !== 'failed')
+            return null;
+        const details = step.statusDetails || {};
+        const message = details.message || '';
+        const stack = details.trace || '';
+        if (!message && !stack)
+            return null;
+        return { message, stack };
+    }
+    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');
+        }
+        // When the final attempt passed (after earlier failures) keep the test as passed —
+        // this mirrors the server's overwrite-by-latest retry model. The aggregated failure
+        // message/stack built above is retained so the flakiness history stays visible.
+        if (finalTest.status === 'passed') {
+            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;

package/lib/bin/cli.js

@@ -10,6 +10,7 @@ const glob_1 = require("glob");
 const debug_1 = __importDefault(require("debug"));
 const client_js_1 = __importDefault(require("../client.js"));
 const xmlReader_js_1 = __importDefault(require("../xmlReader.js"));
+const allureReader_js_1 = __importDefault(require("../allureReader.js"));
 const constants_js_1 = require("../constants.js");
 const utils_js_1 = require("../utils/utils.js");
 const config_js_1 = require("../config.js");
@@ -318,6 +319,33 @@ program
     if (timeoutTimer)
         clearTimeout(timeoutTimer);
 });
+program
+    .command('allure')
+    .description('Parse Allure result files and upload to Testomat.io')
+    .argument('<pattern>', 'Allure result directory pattern')
+    .option('-d, --dir <dir>', 'Project directory')
+    .option('--timelimit <time>', 'default time limit in seconds to kill a stuck process')
+    .option('--with-package', 'Keep full package path in file names (default: strip package prefix)')
+    .action(async (pattern, opts) => {
+    const runReader = new allureReader_js_1.default({ withPackage: opts.withPackage });
+    let timeoutTimer;
+    if (opts.timelimit) {
+        timeoutTimer = setTimeout(() => {
+            console.log(`⚠️  Reached timeout of ${opts.timelimit}s. Exiting... (Exit code is 0 to not fail the pipeline)`);
+            process.exit(0);
+        }, parseInt(opts.timelimit, 10) * 1000);
+    }
+    try {
+        await runReader.parse(pattern);
+        await runReader.createRun();
+        await runReader.uploadData();
+    }
+    catch (err) {
+        console.log(constants_js_1.APP_PREFIX, 'Error uploading Allure results:', err);
+    }
+    if (timeoutTimer)
+        clearTimeout(timeoutTimer);
+});
 program
     .command('upload-artifacts')
     .description('Upload artifacts to Testomat.io')

package/lib/junit-adapter/index.js

@@ -9,6 +9,7 @@ const java_js_1 = __importDefault(require("./java.js"));
 const python_js_1 = __importDefault(require("./python.js"));
 const ruby_js_1 = __importDefault(require("./ruby.js"));
 const csharp_js_1 = __importDefault(require("./csharp.js"));
+const kotlin_js_1 = __importDefault(require("./kotlin.js"));
 function AdapterFactory(lang, opts) {
     if (lang === 'java') {
         return new java_js_1.default(opts);
@@ -25,6 +26,9 @@ function AdapterFactory(lang, opts) {
     if (lang === 'c#' || lang === 'csharp') {
         return new csharp_js_1.default(opts);
     }
+    if (lang === 'kotlin') {
+        return new kotlin_js_1.default(opts);
+    }
     return new adapter_js_1.default(opts);
 }
 module.exports = AdapterFactory;

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

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