@testomatio/reporter 2.7.3 → 2.7.4-beta.allure-1

package/README.md

@@ -69,6 +69,7 @@ yarn add @testomatio/reporter --dev
 | [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....
 
@@ -129,9 +130,10 @@ Bring this reporter on CI and never lose test results again!
   - [CSV](./docs/pipes/csv.md)
   - [HTML report](./docs/pipes/html.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,65 @@
+export default AllureReader;
+declare class AllureReader {
+    constructor(opts?: {});
+    requestParams: {
+        apiKey: any;
+        url: any;
+        title: string;
+        env: string;
+        group_title: string;
+        isBatchEnabled: boolean;
+    };
+    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;
+    }[];
+    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,461 @@
+"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 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,
+            isBatchEnabled: true,
+        };
+        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,
+            isBatchEnabled: this.requestParams.isBatchEnabled,
+        };
+        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,
+        };
+        // 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;
+    }
+    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);
+                }
+                const testId = (0, utils_js_1.fetchIdFromCode)(contents, { lang: this.getLanguage() });
+                if (testId) {
+                    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);
+        // Upload tests individually via addTest (like XML reader does)
+        // so each pipe processes them through its own pipeline
+        for (const test of this._tests) {
+            await Promise.all(this.pipes.map(p => p.addTest(test)));
+        }
+        // Flush any batched tests
+        await Promise.all(this.pipes.map(p => p.sync()));
+        debug('Uploaded %d tests, finishing run', this._tests.length);
+        const finishData = {
+            api_key: this.requestParams.apiKey,
+            status: 'finished',
+            duration: this.stats.duration,
+        };
+        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");
@@ -237,6 +238,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';

package/lib/junit-adapter/kotlin.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const adapter_js_1 = __importDefault(require("./adapter.js"));
+class KotlinAdapter extends adapter_js_1.default {
+    getFilePath(t) {
+        const fileName = namespaceToFileName(t.suite_title);
+        return this.opts.javaTests + path_1.default.sep + fileName;
+    }
+    formatTest(t) {
+        const fileParts = t.suite_title.split('.');
+        t.file = namespaceToFileName(t.suite_title);
+        t.title = t.title.split('(')[0];
+        // detect params
+        const paramMatches = t.title.match(/\[(.*?)\]/g);
+        if (paramMatches) {
+            const params = paramMatches.map((_match, index) => `param${index + 1}`);
+            if (params.length === 1)
+                params[0] = 'param';
+            let paramIndex = 0;
+            t.title = t.title.replace(/: \[(.*?)\]/g, () => {
+                if (params.length < 2)
+                    return `\${param}`;
+                const paramName = params[paramIndex] || `param${paramIndex + 1}`;
+                paramIndex++;
+                return `\${${paramName}}`;
+            });
+            const example = {};
+            paramMatches.forEach((match, index) => {
+                example[params[index]] = match.replace(/[[\]]/g, '');
+            });
+            t.example = example;
+        }
+        t.suite_title = fileParts[fileParts.length - 1].replace(/\$/g, ' | ');
+        return t;
+    }
+}
+function namespaceToFileName(fileName) {
+    const fileParts = fileName.split('.');
+    fileParts[fileParts.length - 1] = fileParts[fileParts.length - 1]?.replace(/\$.*/, '');
+    return `${fileParts.join(path_1.default.sep)}.kt`;
+}
+module.exports = KotlinAdapter;

package/lib/pipe/html.js

@@ -180,12 +180,8 @@ class HtmlPipe {
                 ...(test.meta?.attachments || []),
             ];
             test.artifactsUploaded = allPossibleArtifacts.some(artifact => {
-                let link = artifact?.link || artifact?.path;
-                if (!link)
-                    return false;
-                if (typeof link !== 'string')
-                    link = String(link);
-                return link.startsWith('http://') || link.startsWith('https://');
+                const link = artifact?.link || artifact?.path;
+                return link && (link.startsWith('http://') || link.startsWith('https://')) && !link.startsWith('file://');
             });
             normalizeRetries(test);
             if (test.traces) {