@testomatio/reporter 2.0.0-beta-esm → 2.0.1-beta-esm

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.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.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,45 @@
+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,16 +1,43 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 = void 0;
+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 debug = (0, debug_1.default)('@testomatio/reporter:util');
 /**
  * @param {String} testTitle - Test title
@@ -319,9 +346,49 @@ 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;
+}
+
+module.exports.formatStep = formatStep;
+
+module.exports.readLatestRunId = readLatestRunId;
 
 module.exports.removeColorCodes = removeColorCodes;
 
+module.exports.storeRunId = storeRunId;
+
 module.exports.getTestomatIdFromTestTitle = getTestomatIdFromTestTitle;
 
 module.exports.parseSuite = parseSuite;

package/lib/xmlReader.d.ts

@@ -0,0 +1,92 @@
+export default XmlReader;
+declare class XmlReader {
+    constructor(opts?: {});
+    requestParams: {
+        apiKey: any;
+        url: any;
+        title: string;
+        env: string;
+        group_title: string;
+        detach: string;
+        isBatchEnabled: boolean;
+    };
+    runId: any;
+    adapter: import("./junit-adapter/adapter.js").default;
+    opts: {};
+    store: {};
+    pipesPromise: Promise<any[]>;
+    parser: XMLParser;
+    tests: any[];
+    stats: {};
+    uploader: S3Uploader;
+    version: any;
+    connectAdapter(): import("./junit-adapter/adapter.js").default;
+    parse(fileName: any): {
+        status: string;
+        create_tests: boolean;
+        tests_count: number;
+        passed_count: number;
+        skipped_count: number;
+        failed_count: number;
+        tests: any;
+    } | {
+        status: any;
+        create_tests: boolean;
+        tests_count: number;
+        passed_count: number;
+        failed_count: number;
+        skipped_count: number;
+        tests: any[];
+    };
+    processJUnit(jsonSuite: any): {
+        create_tests: boolean;
+        duration: number;
+        failed_count: number;
+        name: any;
+        passed_count: number;
+        skipped_count: number;
+        status: string;
+        tests: any[];
+        tests_count: number;
+    };
+    processNUnit(jsonSuite: any): {
+        status: any;
+        create_tests: boolean;
+        tests_count: number;
+        passed_count: number;
+        failed_count: number;
+        skipped_count: number;
+        tests: any[];
+    };
+    processTRX(jsonSuite: any): {
+        status: string;
+        create_tests: boolean;
+        tests_count: number;
+        passed_count: number;
+        skipped_count: number;
+        failed_count: number;
+        tests: any;
+    };
+    processXUnit(assemblies: any): {
+        status: string;
+        create_tests: boolean;
+        name: string;
+        tests_count: number;
+        passed_count: number;
+        failed_count: number;
+        skipped_count: number;
+        tests: any[];
+    };
+    calculateStats(): {};
+    fetchSourceCode(): void;
+    formatTests(): void;
+    formatErrors(): void;
+    formatStack(t: any): any;
+    uploadArtifacts(): Promise<void>;
+    createRun(): Promise<any[]>;
+    pipes: any;
+    uploadData(): Promise<any[]>;
+    _finishRun(): Promise<any[]>;
+}
+import { XMLParser } from 'fast-xml-parser';
+import { S3Uploader } from './uploader.js';