@testomatio/reporter 2.0.0-beta-esm → 2.0.0-beta.1-xml

package/lib/uploader.d.ts

@@ -0,0 +1,60 @@
+export class S3Uploader {
+    isEnabled: any;
+    storeEnabled: boolean;
+    config: {};
+    /**
+     * @type {{path: string, size: number}[]}
+     */
+    skippedUploads: {
+        path: string;
+        size: number;
+    }[];
+    failedUploads: any[];
+    /**
+     * @type {{path: string, size: number, link: string}[]}
+     */
+    successfulUploads: {
+        path: string;
+        size: number;
+        link: string;
+    }[];
+    configKeys: string[];
+    resetConfig(): void;
+    /**
+     *
+     * @returns {Record<string, string>}
+     */
+    getConfig(): Record<string, string>;
+    getMaskedConfig(): {
+        [k: string]: string;
+    };
+    checkEnabled(): any;
+    enableLogStorage(): void;
+    disableLogStorage(): void;
+    /**
+     * Returns an array of uploaded files
+     *
+     * @returns {{rid: string, file: string, uploaded: boolean}[]}
+     */
+    readUploadedFiles(runId: any): {
+        rid: string;
+        file: string;
+        uploaded: boolean;
+    }[];
+    storeUploadedFile(filePath: any, runId: any, rid: any, uploaded?: boolean): void;
+    /**
+     * @param {*} filePath
+     * @param {*} pathInS3 contains runId, rid and filename
+     * @returns
+     */
+    uploadFileByPath(filePath: any, pathInS3: any): Promise<any>;
+    /**
+     * @param {Buffer} buffer
+     * @param {string[]} pathInS3
+     * @returns
+     */
+    uploadFileAsBuffer(buffer: Buffer, pathInS3: string[]): Promise<any>;
+    checkArtifactExistsInFileSystem(filePath: any, attempts?: number, intervalMs?: number): Promise<any>;
+    getS3LocationLink(out: any): Promise<any>;
+    #private;
+}

package/lib/uploader.js

@@ -0,0 +1,312 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Uploader = void 0;
+const debug_1 = __importDefault(require("debug"));
+const client_s3_1 = require("@aws-sdk/client-s3");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promise_retry_1 = __importDefault(require("promise-retry"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const constants_js_1 = require("./constants.js");
+const filesize_1 = require("filesize");
+const debug = (0, debug_1.default)('@testomatio/reporter:file-uploader');
+class S3Uploader {
+    constructor() {
+        this.isEnabled = undefined;
+        this.storeEnabled = true;
+        this.config = undefined;
+        /**
+         * @type {{path: string, size: number}[]}
+         */
+        this.skippedUploads = [];
+        this.failedUploads = [];
+        /**
+         * @type {{path: string, size: number, link: string}[]}
+         */
+        this.successfulUploads = [];
+        this.configKeys = [
+            'S3_ENDPOINT',
+            'S3_REGION',
+            'S3_BUCKET',
+            'S3_ACCESS_KEY_ID',
+            'S3_SECRET_ACCESS_KEY',
+            'S3_SESSION_TOKEN',
+            'S3_FORCE_PATH_STYLE',
+            'TESTOMATIO_DISABLE_ARTIFACTS',
+            'TESTOMATIO_PRIVATE_ARTIFACTS',
+            'TESTOMATIO_ARTIFACT_MAX_SIZE_MB',
+        ];
+    }
+    resetConfig() {
+        this.config = undefined;
+        this.isEnabled = undefined;
+    }
+    /**
+     *
+     * @returns {Record<string, string>}
+     */
+    getConfig() {
+        if (this.config)
+            return this.config;
+        this.config = this.configKeys.reduce((acc, key) => {
+            acc[key] = process.env[key];
+            return acc;
+        }, {});
+        return this.config;
+    }
+    getMaskedConfig() {
+        return Object.fromEntries(Object.entries(this.getConfig()).map(([key, value]) => [
+            key,
+            key === 'S3_SECRET_ACCESS_KEY' || key === 'S3_ACCESS_KEY_ID' ? '***' : value,
+        ]));
+    }
+    checkEnabled() {
+        if (this.isEnabled !== undefined)
+            return this.isEnabled;
+        const { S3_BUCKET, TESTOMATIO_DISABLE_ARTIFACTS } = this.getConfig();
+        if (!S3_BUCKET)
+            debug(`Artifacts uploading is disabled because S3_BUCKET is not set`);
+        this.isEnabled = !!(S3_BUCKET && !TESTOMATIO_DISABLE_ARTIFACTS);
+        if (this.isEnabled)
+            debug('S3 uploader is enabled');
+        debug(this.getMaskedConfig());
+        return this.isEnabled;
+    }
+    enableLogStorage() {
+        this.storeEnabled = true;
+    }
+    disableLogStorage() {
+        this.storeEnabled = false;
+    }
+    /**
+     *
+     * @param {*} Body
+     * @param {*} Key
+     * @param {{path: string, size?: number}} file
+     * @returns
+     */
+    async #uploadToS3(Body, Key, file) {
+        const { S3_BUCKET, TESTOMATIO_PRIVATE_ARTIFACTS } = this.getConfig();
+        const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
+        if (!S3_BUCKET || !Body) {
+            console.log(constants_js_1.APP_PREFIX, picocolors_1.default.bold(picocolors_1.default.red(`Failed uploading '${Key}'. Please check S3 credentials`)), this.getMaskedConfig());
+            return;
+        }
+        debug('Uploading to S3:', Key);
+        const s3Config = this.#getS3Config();
+        const s3 = new client_s3_1.S3(s3Config);
+        const params = {
+            Bucket: S3_BUCKET,
+            Key,
+            Body,
+        };
+        // disable ACL for I AM roles
+        if (!s3Config.credentials.sessionToken) {
+            params.ACL = ACL;
+        }
+        try {
+            const upload = new lib_storage_1.Upload({ client: s3, params });
+            const link = await this.getS3LocationLink(upload);
+            this.successfulUploads.push({ path: file.path, size: file.size, link });
+            debug(`📤 Uploaded artifact. File: ${file.path}, size: ${(0, filesize_1.filesize)(file.size)}, link: ${link}`);
+            return link;
+        }
+        catch (e) {
+            this.failedUploads.push({ path: file.path, size: file.size });
+            debug('S3 uploading error:', e);
+            console.log(constants_js_1.APP_PREFIX, 'Upload failed:', e.message, '\nConfig:\n', this.getMaskedConfig());
+        }
+    }
+    /**
+     * Returns an array of uploaded files
+     *
+     * @returns {{rid: string, file: string, uploaded: boolean}[]}
+     */
+    readUploadedFiles(runId) {
+        const tempFilePath = this.#getFilePathWithUploadsList(runId);
+        debug('Reading file', tempFilePath);
+        if (!fs_1.default.existsSync(tempFilePath)) {
+            debug('File not found:', tempFilePath);
+            return [];
+        }
+        const stats = fs_1.default.statSync(tempFilePath);
+        debug('Artifacts file stats:', +stats.mtime);
+        debug('Current time:', +new Date());
+        const diff = +new Date() - +stats.mtime;
+        debug('Diff:', diff);
+        const diffHours = diff / 1000 / 60 / 60;
+        debug('Diff hours:', diffHours);
+        if (diffHours > 3) {
+            console.log(constants_js_1.APP_PREFIX, "Artifacts file is too old, can't process artifacts. Please re-run the tests.");
+            return [];
+        }
+        const data = fs_1.default.readFileSync(tempFilePath, 'utf8');
+        debug('Artifacts file contents:', data);
+        const lines = data.split('\n').filter(Boolean);
+        return lines.map(line => JSON.parse(line));
+    }
+    #getFilePathWithUploadsList(runId) {
+        const tempFilePath = path_1.default.join(os_1.default.tmpdir(), `testomatio.run.${runId}.json`);
+        if (!fs_1.default.existsSync(tempFilePath)) {
+            debug('Creating artifacts file:', tempFilePath);
+            fs_1.default.writeFileSync(tempFilePath, '');
+        }
+        return tempFilePath;
+    }
+    storeUploadedFile(filePath, runId, rid, uploaded = false) {
+        if (!this.storeEnabled)
+            return;
+        if (!filePath || !runId || !rid)
+            return;
+        const tempFilePath = this.#getFilePathWithUploadsList(runId);
+        if (typeof filePath === 'object') {
+            filePath = filePath.path;
+        }
+        if (typeof filePath === 'string' && !path_1.default.isAbsolute(filePath)) {
+            filePath = path_1.default.join(process.cwd(), filePath);
+        }
+        const data = { rid, file: filePath, uploaded };
+        const jsonLine = `${JSON.stringify(data)}\n`;
+        fs_1.default.appendFileSync(tempFilePath, jsonLine);
+    }
+    /**
+     * @param {*} filePath
+     * @param {*} pathInS3 contains runId, rid and filename
+     * @returns
+     */
+    async uploadFileByPath(filePath, pathInS3) {
+        // sometimes artifacts uploading started before createRun function completion
+        this.isEnabled = this.isEnabled ?? this.checkEnabled();
+        const [runId, rid] = pathInS3;
+        if (!filePath)
+            return;
+        let fileSize = null;
+        let fileSizeInMb = null;
+        try {
+            // file may not exist
+            fileSize = fs_1.default.statSync(filePath).size;
+            fileSizeInMb = Number((fileSize / (1024 * 1024)).toFixed(2));
+        }
+        catch (e) {
+            debug(`File ${filePath} does not exist`);
+        }
+        if (!this.isEnabled) {
+            this.storeUploadedFile(filePath, runId, rid, false);
+            this.skippedUploads.push({ path: filePath, size: fileSize });
+            return;
+        }
+        const { S3_BUCKET, TESTOMATIO_ARTIFACT_MAX_SIZE_MB } = this.getConfig();
+        debug('Started upload', filePath, 'to', S3_BUCKET);
+        const isFileExist = await this.checkArtifactExistsInFileSystem(filePath, 20, 500);
+        if (!isFileExist) {
+            console.error(picocolors_1.default.yellow(`Artifacts file ${filePath} does not exist. Skipping...`));
+            return;
+        }
+        // skipping artifact only if: 1. storing to file is enabled, 2. max size is set and 3. file size exceeds the limit
+        if (this.storeEnabled &&
+            TESTOMATIO_ARTIFACT_MAX_SIZE_MB &&
+            fileSizeInMb > parseFloat(TESTOMATIO_ARTIFACT_MAX_SIZE_MB)) {
+            const skippedArtifact = { path: filePath, size: fileSize };
+            this.storeUploadedFile(filePath, runId, rid, false);
+            this.skippedUploads.push(skippedArtifact);
+            debug(picocolors_1.default.yellow(`Artifacts file ${JSON.stringify(skippedArtifact)} exceeds the maximum allowed size. Skipping.`));
+            return;
+        }
+        debug('File:', filePath, 'exists, size:', (0, filesize_1.filesize)(fileSize));
+        const fileStream = fs_1.default.createReadStream(filePath);
+        const Key = pathInS3.filter(p => !!p).join('/');
+        const link = await this.#uploadToS3(fileStream, Key, { path: filePath, size: fileSize });
+        this.storeUploadedFile(filePath, runId, rid, !!link);
+        return link;
+    }
+    /**
+     * @param {Buffer} buffer
+     * @param {string[]} pathInS3
+     * @returns
+     */
+    async uploadFileAsBuffer(buffer, pathInS3) {
+        if (!this.isEnabled)
+            return;
+        let Key = pathInS3.filter(p => !!p).join('/');
+        const ext = this.#getFileExtBase64(buffer);
+        if (ext) {
+            Key = `${Key}.${ext}`;
+        }
+        return this.#uploadToS3(buffer, Key, { path: Key });
+    }
+    async checkArtifactExistsInFileSystem(filePath, attempts = 5, intervalMs = 500) {
+        return (0, promise_retry_1.default)(async (retry, number) => {
+            try {
+                fs_1.default.accessSync(filePath);
+                return true;
+            }
+            catch (err) {
+                if (number === attempts) {
+                    return false;
+                }
+                debug(`File not found, retrying (attempt ${number}/${attempts})`);
+                await new Promise(resolve => {
+                    setTimeout(resolve, intervalMs);
+                });
+                retry(err);
+            }
+        }, {
+            retries: attempts,
+            minTimeout: intervalMs,
+            maxTimeout: intervalMs,
+        });
+    }
+    async getS3LocationLink(out) {
+        const response = await out.done();
+        let s3Location = response?.Location?.trim();
+        if (!s3Location) {
+            s3Location = out?.singleUploadResult?.Location;
+            debug('Uploaded singleUploadResult.Location', s3Location);
+            if (!s3Location) {
+                throw new Error("Problems getting the S3 artifact's link. Please check S3 permissions!");
+            }
+        }
+        // Normalize the URL
+        if (!s3Location.startsWith('http')) {
+            s3Location = `https://${s3Location}`;
+        }
+        return s3Location;
+    }
+    #getFileExtBase64(str) {
+        const type = str.charAt(0);
+        return ({
+            '/': 'jpg',
+            i: 'png',
+            R: 'gif',
+            U: 'webp',
+        }[type] || '');
+    }
+    #getS3Config() {
+        const { S3_REGION, S3_SESSION_TOKEN, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY, S3_FORCE_PATH_STYLE, S3_ENDPOINT } = this.getConfig();
+        const cfg = {
+            region: S3_REGION,
+            credentials: {
+                accessKeyId: S3_ACCESS_KEY_ID,
+                secretAccessKey: S3_SECRET_ACCESS_KEY,
+            },
+        };
+        if (S3_FORCE_PATH_STYLE) {
+            cfg.forcePathStyle = !['false', '0'].includes(String(S3_FORCE_PATH_STYLE || '').toLowerCase());
+        }
+        if (S3_SESSION_TOKEN) {
+            cfg.credentials.sessionToken = S3_SESSION_TOKEN;
+        }
+        if (S3_ENDPOINT) {
+            cfg.endpoint = S3_ENDPOINT;
+        }
+        return cfg;
+    }
+}
+exports.S3Uploader = S3Uploader;
+
+module.exports.S3Uploader = S3Uploader;

package/lib/utils/pipe_utils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Update and validate the filter type.
+ * @param {string} type - The original filter type.
+ * @returns {string|undefined} The updated and validated filter type.
+ *                            Returns undefined if the type is not valid.
+ */
+export function updateFilterType(type: string): string | undefined;
+/**
+ * Parse filter parameters from a string in the format "type=id".
+ * @param {string} opts - The input string containing the filter parameters.
+ * @returns {Object} An object containing the parsed filter parameters.
+ *                   The object has properties "type" and "id".
+ */
+export function parseFilterParams(opts: string): any;
+/**
+ * Generates mode request parameters based on the input params.
+ * @param {{type: string, id?: string, apiKey: string}} params - The input parameters for the request.
+ * @returns {Object|null} - An object containing the generated request parameters, or null if the type is invalid.
+ */
+export function generateFilterRequestParams(params: {
+    type: string;
+    id?: string;
+    apiKey: string;
+}): any | null;
+/**
+ * Set S3 credentials from the provided artifacts object.
+ * @param {Object} artifacts - The artifacts object containing S3 credentials.
+ */
+export function setS3Credentials(artifacts: any): void;
+/**
+ * Return an emoji based on the provided status.
+ * @param {string} status - The status value ('passed', 'failed', or 'skipped').
+ * @returns {string} - An emoji corresponding to the provided status.
+ */
+export function statusEmoji(status: string): string;
+/**
+ * Generate a full name string based on the provided test object.
+ * @param {object} t - The test object.
+ * @returns {string} - A formatted full name string for the test object.
+ */
+export function fullName(t: object): string;

package/lib/utils/pipe_utils.js

@@ -6,7 +6,6 @@ exports.generateFilterRequestParams = generateFilterRequestParams;
 exports.setS3Credentials = setS3Credentials;
 exports.statusEmoji = statusEmoji;
 exports.fullName = fullName;
-const fileUploader_js_1 = require("../fileUploader.js");
 const constants_js_1 = require("../constants.js");
 /**
  * Set S3 credentials from the provided artifacts object.
@@ -15,7 +14,7 @@ const constants_js_1 = require("../constants.js");
 function setS3Credentials(artifacts) {
     if (!Object.keys(artifacts).length)
         return;
-    console.log(constants_js_1.APP_PREFIX, 'S3 were credentials obtained from Testomat.io...');
+    console.log(constants_js_1.APP_PREFIX, 'S3 credentials obtained from Testomat.io...');
     if (artifacts.ACCESS_KEY_ID)
         process.env.S3_ACCESS_KEY_ID = artifacts.ACCESS_KEY_ID;
     if (artifacts.SECRET_ACCESS_KEY)
@@ -24,13 +23,12 @@ function setS3Credentials(artifacts) {
         process.env.S3_REGION = artifacts.REGION;
     if (artifacts.BUCKET)
         process.env.S3_BUCKET = artifacts.BUCKET;
-    if (artifacts.ENDPOINT)
-        process.env.S3_ENDPOINT = artifacts.ENDPOINT;
     if (artifacts.SESSION_TOKEN)
         process.env.S3_SESSION_TOKEN = artifacts.SESSION_TOKEN;
     if (artifacts.presign)
         process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
-    fileUploader_js_1.upload.resetConfig();
+    // endpoint is not received from the server; and shuld be empty if IAM used (credentails obtained from the testomat)
+    process.env.S3_ENDPOINT = artifacts.ENDPOINT || '';
 }
 /**
  * Generates mode request parameters based on the input params.

package/lib/utils/utils.d.ts

@@ -0,0 +1,47 @@
+export function getPackageVersion(): any;
+export const TEST_ID_REGEX: RegExp;
+export function ansiRegExp(): RegExp;
+export function isSameTest(test: any, t: any): boolean;
+export function fetchSourceCode(contents: any, opts?: {}): string;
+export function fetchSourceCodeFromStackTrace(stack?: string): string;
+export function fetchIdFromCode(code: any, opts?: {}): any;
+export function fetchIdFromOutput(output: any): any;
+export function fetchFilesFromStackTrace(stack?: string): string[];
+export namespace fileSystem {
+    function createDir(dirPath: any): void;
+    function clearDir(dirPath: any): void;
+}
+export function foundedTestLog(app: any, tests: any): void;
+export function formatStep(step: any, shift?: number): any;
+export function getCurrentDateTime(): string;
+/**
+ * @param {String} testTitle - Test title
+ *
+ * @returns {String|null} testId
+ */
+export function getTestomatIdFromTestTitle(testTitle: string): string | null;
+export function humanize(text: any): any;
+export function isValidUrl(s: any): boolean;
+/**
+ * @param {String} suiteTitle - suite title
+ *
+ * @returns {String|null} suiteId
+ */
+export function parseSuite(suiteTitle: string): string | null;
+export function readLatestRunId(): string;
+/**
+ * Used to remove color codes
+ * @param {*} input
+ * @returns
+ */
+export function removeColorCodes(input: any): any;
+/**
+ * @param {Object} test - Test adapter object
+ *
+ * @returns {String|null} testInfo as one string
+ */
+export function specificTestInfo(test: any): string | null;
+export function storeRunId(runId: any): void;
+export namespace testRunnerHelper {
+    function getNameOfCurrentlyRunningTest(): any;
+}

package/lib/utils/utils.js

@@ -1,17 +1,57 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testRunnerHelper = exports.foundedTestLog = exports.humanize = exports.parseSuite = exports.getTestomatIdFromTestTitle = exports.ansiRegExp = exports.isValidUrl = exports.specificTestInfo = exports.getCurrentDateTime = exports.fileSystem = exports.fetchFilesFromStackTrace = exports.fetchIdFromOutput = exports.fetchIdFromCode = exports.fetchSourceCodeFromStackTrace = exports.fetchSourceCode = exports.isSameTest = void 0;
+exports.testRunnerHelper = exports.specificTestInfo = exports.parseSuite = exports.isValidUrl = exports.humanize = exports.getTestomatIdFromTestTitle = exports.getCurrentDateTime = exports.foundedTestLog = exports.fileSystem = exports.fetchFilesFromStackTrace = exports.fetchIdFromOutput = exports.fetchIdFromCode = exports.fetchSourceCodeFromStackTrace = exports.fetchSourceCode = exports.isSameTest = exports.ansiRegExp = exports.TEST_ID_REGEX = void 0;
+exports.getPackageVersion = getPackageVersion;
+exports.formatStep = formatStep;
+exports.readLatestRunId = readLatestRunId;
 exports.removeColorCodes = removeColorCodes;
+exports.storeRunId = storeRunId;
 const url_1 = require("url");
-const path_1 = require("path");
+const path_1 = __importStar(require("path"));
 const picocolors_1 = __importDefault(require("picocolors"));
 const fs_1 = __importDefault(require("fs"));
 const is_valid_path_1 = __importDefault(require("is-valid-path"));
 const debug_1 = __importDefault(require("debug"));
+const os_1 = __importDefault(require("os"));
+const url_2 = require("url");
 const debug = (0, debug_1.default)('@testomatio/reporter:util');
+// Use __dirname directly since we're compiling to CommonJS
 /**
  * @param {String} testTitle - Test title
  *
@@ -50,7 +90,6 @@ const ansiRegExp = () => {
 exports.ansiRegExp = ansiRegExp;
 const isValidUrl = s => {
     try {
-        // eslint-disable-next-line no-new
         new url_1.URL(s);
         return true;
     }
@@ -104,7 +143,7 @@ const fetchSourceCodeFromStackTrace = (stack = '') => {
         .join('\n');
 };
 exports.fetchSourceCodeFromStackTrace = fetchSourceCodeFromStackTrace;
-const TEST_ID_REGEX = /@T([\w\d]{8})/;
+exports.TEST_ID_REGEX = /@T([\w\d]{8})/;
 const fetchIdFromCode = (code, opts = {}) => {
     const comments = code
         .split('\n')
@@ -118,15 +157,12 @@ const fetchIdFromCode = (code, opts = {}) => {
                 return l.startsWith('// ');
         }
     });
-    return comments.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+    return comments.find(c => c.match(exports.TEST_ID_REGEX))?.match(exports.TEST_ID_REGEX)?.[1];
 };
 exports.fetchIdFromCode = fetchIdFromCode;
 const fetchIdFromOutput = output => {
-    const lines = output
-        .split('\n')
-        .map(l => l.trim())
-        .filter(l => l.startsWith('tid://'));
-    return lines.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+    const TID_FULL_PATTERN = new RegExp(`tid:\\/\\/.*?(${exports.TEST_ID_REGEX.source})`);
+    return output.match(TID_FULL_PATTERN)?.[2];
 };
 exports.fetchIdFromOutput = fetchIdFromOutput;
 const fetchSourceCode = (contents, opts = {}) => {
@@ -150,6 +186,12 @@ const fetchSourceCode = (contents, opts = {}) => {
             if (lineIndex === -1)
                 lineIndex = lines.findIndex(l => l.includes(`${title}(`));
         }
+        else if (opts.lang === 'csharp') {
+            if (lineIndex === -1)
+                lineIndex = lines.findIndex(l => l.includes(`public void ${title}`));
+            if (lineIndex === -1)
+                lineIndex = lines.findIndex(l => l.includes(`${title}(`));
+        }
         else {
             lineIndex = lines.findIndex(l => l.includes(title));
         }
@@ -297,7 +339,6 @@ const decamelize = text => {
  * @returns
  */
 function removeColorCodes(input) {
-    // eslint-disable-next-line no-control-regex
     return input.replace(/\x1b\[[0-9;]*m/g, '');
 }
 const testRunnerHelper = {
@@ -310,7 +351,6 @@ const testRunnerHelper = {
         try {
             // TODO: expect?.getState()?.testPath + ' ' + expect?.getState()?.currentTestName
             // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
-            // eslint-disable-next-line no-undef
             return expect?.getState()?.currentTestName;
         }
         catch (e) {
@@ -319,9 +359,56 @@ const testRunnerHelper = {
     },
 };
 exports.testRunnerHelper = testRunnerHelper;
+function storeRunId(runId) {
+    if (!runId || runId === 'undefined')
+        return;
+    const filePath = path_1.default.join(os_1.default.tmpdir(), `testomatio.latest.run`);
+    fs_1.default.writeFileSync(filePath, runId);
+}
+function readLatestRunId() {
+    try {
+        const filePath = path_1.default.join(os_1.default.tmpdir(), `testomatio.latest.run`);
+        const stats = fs_1.default.statSync(filePath);
+        const diff = +new Date() - +stats.mtime;
+        const diffHours = diff / 1000 / 60 / 60;
+        if (diffHours > 1)
+            return;
+        return fs_1.default.readFileSync(filePath)?.toString()?.trim();
+    }
+    catch (e) {
+        return null;
+    }
+}
+function formatStep(step, shift = 0) {
+    const prefix = ' '.repeat(shift);
+    const lines = [];
+    if (step.error) {
+        lines.push(`${prefix}${picocolors_1.default.red(step.title)} ${picocolors_1.default.gray(`${step.duration}ms`)}`);
+    }
+    else {
+        lines.push(`${prefix}${step.title} ${picocolors_1.default.gray(`${step.duration}ms`)}`);
+    }
+    for (const child of step.steps || []) {
+        lines.push(...formatStep(child, shift + 2));
+    }
+    return lines;
+}
+function getPackageVersion() {
+    const packageJsonPath = path_1.default.resolve(__dirname, '../../package.json');
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.version;
+}
+
+module.exports.getPackageVersion = getPackageVersion;
+
+module.exports.formatStep = formatStep;
+
+module.exports.readLatestRunId = readLatestRunId;
 
 module.exports.removeColorCodes = removeColorCodes;
 
+module.exports.storeRunId = storeRunId;
+
 module.exports.getTestomatIdFromTestTitle = getTestomatIdFromTestTitle;
 
 module.exports.parseSuite = parseSuite;