@testomatio/reporter 1.6.17-beta-artifacts → 1.6.17-beta.2-tls-fix

package/lib/pipe/testomatio.d.ts

@@ -0,0 +1,70 @@
+export default TestomatioPipe;
+export type Pipe = import("../../types/types.js").Pipe;
+export type TestData = import("../../types/types.js").TestData;
+/**
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
+ * @class TestomatioPipe
+ * @implements {Pipe}
+ */
+declare class TestomatioPipe implements Pipe {
+    constructor(params: any, store: any);
+    batch: {
+        isEnabled: any;
+        intervalFunction: any;
+        intervalTime: number;
+        tests: any[];
+        batchIndex: number;
+        numberOfTimesCalledWithoutTests: number;
+    };
+    retriesTimestamps: any[];
+    reportingCanceledDueToReqFailures: boolean;
+    notReportedTestsCount: number;
+    isEnabled: boolean;
+    url: any;
+    apiKey: any;
+    parallel: any;
+    store: any;
+    title: any;
+    sharedRun: boolean;
+    sharedRunTimeout: boolean;
+    groupTitle: any;
+    env: string;
+    label: string;
+    axios: import("axios").AxiosInstance;
+    proceed: string;
+    jiraId: string;
+    runId: any;
+    createNewTests: any;
+    hasUnmatchedTests: boolean;
+    requestFailures: number;
+    /**
+     * Asynchronously prepares and retrieves the Testomat.io test grepList based on the provided options.
+     * @param {Object} opts - The options for preparing the test grepList.
+     * @returns {Promise<string[]>} - An array containing the retrieved
+     * test grepList, or an empty array if no tests are found or the request is disabled.
+     * @throws {Error} - Throws an error if there was a problem while making the request.
+     */
+    prepareRun(opts: any): Promise<string[]>;
+    /**
+     * Creates a new run on Testomat.io
+     * @param {{isBatchEnabled?: boolean}} params
+     * @returns Promise<void>
+     */
+    createRun(params?: {
+        isBatchEnabled?: boolean;
+    }): Promise<void>;
+    runUrl: string;
+    runPublicUrl: any;
+    /**
+     * Adds a test to the batch uploader (or reports a single test if batch uploading is disabled)
+     */
+    addTest(data: any): void;
+    /**
+     * @param {import('../../types/types.js').RunData} params
+     * @returns
+     */
+    finishRun(params: import("../../types/types.js").RunData): Promise<void>;
+    toString(): string;
+    #private;
+}

package/lib/pipe/testomatio.js

@@ -3,6 +3,7 @@ const chalk = require('chalk');
 // Retry interceptor function
 const axiosRetry = require('axios-retry');
 // Default axios instance
+const https = require('https');
 const axios = require('axios');
 const JsonCycle = require('json-cycle');
 
@@ -57,6 +58,11 @@ class TestomatioPipe {
     // Create a new instance of axios with a custom config
     this.axios = axios.create({
       baseURL: `${this.url.trim()}`,
+      maxRedirects: 0,
+      httpsAgent: new https.Agent({
+        rejectUnauthorized: true,
+        keepAlive: false,
+      }),
       timeout: AXIOS_TIMEOUT,
       proxy: proxy ? {
         host: proxy.hostname,

package/lib/reporter-functions.d.ts

@@ -0,0 +1,34 @@
+declare namespace _default {
+    export { saveArtifact as artifact };
+    export { logMessage as log };
+    export { addStep as step };
+    export { setKeyValue as keyValue };
+}
+export default _default;
+/**
+ * Stores path to file as artifact and uploads it to the S3 storage
+ * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
+ */
+declare function saveArtifact(data: string | {
+    path: string;
+    type: string;
+    name: string;
+}, context?: any): void;
+/**
+ * Attach log message(s) to the test report
+ * @param  string
+ */
+declare function logMessage(...args: any[]): void;
+/**
+ * Similar to "log" function but marks message in report as a step
+ * @param {string} message
+ */
+declare function addStep(message: string): void;
+/**
+ * Add key-value pair(s) to the test report
+ * @param {{[key: string]: string} | string} keyValue object { key: value } (multiple props allowed) or key (string)
+ * @param {string?} value
+ */
+declare function setKeyValue(keyValue: {
+    [key: string]: string;
+} | string, value?: string | null): void;

package/lib/reporter.d.ts

@@ -0,0 +1,232 @@
+export type artifact = typeof import("./reporter-functions.js");
+export const artifact: (data: string | {
+    path: string;
+    type: string;
+    name: string;
+}, context?: any) => void;
+export type log = typeof import("./reporter-functions.js");
+export const log: (...args: any[]) => void;
+export type logger = typeof import("./services/index.js");
+export const logger: {
+    "__#12@#originalUserLogger": {
+        assert(condition?: boolean, ...data: any[]): void;
+        assert(value: any, message?: string, ...optionalParams: any[]): void;
+        clear(): void;
+        clear(): void;
+        count(label?: string): void;
+        count(label?: string): void;
+        countReset(label?: string): void;
+        countReset(label?: string): void;
+        debug(...data: any[]): void;
+        debug(message?: any, ...optionalParams: any[]): void;
+        dir(item?: any, options?: any): void;
+        dir(obj: any, options?: import("util").InspectOptions): void;
+        dirxml(...data: any[]): void;
+        dirxml(...data: any[]): void;
+        error(...data: any[]): void;
+        error(message?: any, ...optionalParams: any[]): void;
+        group(...data: any[]): void;
+        group(...label: any[]): void;
+        groupCollapsed(...data: any[]): void;
+        groupCollapsed(...label: any[]): void;
+        groupEnd(): void;
+        groupEnd(): void;
+        info(...data: any[]): void;
+        info(message?: any, ...optionalParams: any[]): void;
+        log(...data: any[]): void;
+        log(message?: any, ...optionalParams: any[]): void;
+        table(tabularData?: any, properties?: string[]): void;
+        table(tabularData: any, properties?: readonly string[]): void;
+        time(label?: string): void;
+        time(label?: string): void;
+        timeEnd(label?: string): void;
+        timeEnd(label?: string): void;
+        timeLog(label?: string, ...data: any[]): void;
+        timeLog(label?: string, ...data: any[]): void;
+        timeStamp(label?: string): void;
+        timeStamp(label?: string): void;
+        trace(...data: any[]): void;
+        trace(message?: any, ...optionalParams: any[]): void;
+        warn(...data: any[]): void;
+        warn(message?: any, ...optionalParams: any[]): void;
+        Console: console.ConsoleConstructor;
+        profile(label?: string): void;
+        profileEnd(label?: string): void;
+    };
+    "__#12@#userLoggerWithOverridenMethods": any;
+    logLevel: string;
+    step(strings: any, ...values: any[]): void;
+    getLogs(context: string): string[];
+    "__#12@#stringifyLogs"(...args: any[]): string;
+    _templateLiteralLog(strings: any, ...args: any[]): void;
+    "__#12@#logWrapper"(argsArray: any, level: any): void;
+    assert(...args: any[]): void;
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    trace(...args: any[]): void;
+    warn(...args: any[]): void;
+    intercept(userLogger: any): void;
+    stopInterception(): void;
+    configure(config?: {
+        logLevel?: string;
+        prettyObjects?: boolean;
+    }): void;
+    prettyObjects: boolean;
+};
+export type meta = typeof import("./reporter-functions.js");
+export const meta: (keyValue: {
+    [key: string]: string;
+} | string, value?: string | null) => void;
+export type step = typeof import("./reporter-functions.js");
+export const step: (message: string) => void;
+declare namespace _default {
+    let testomatioLogger: {
+        "__#12@#originalUserLogger": {
+            assert(condition?: boolean, ...data: any[]): void;
+            assert(value: any, message?: string, ...optionalParams: any[]): void;
+            clear(): void;
+            clear(): void;
+            count(label?: string): void;
+            count(label?: string): void;
+            countReset(label?: string): void;
+            countReset(label?: string): void;
+            debug(...data: any[]): void;
+            debug(message?: any, ...optionalParams: any[]): void;
+            dir(item?: any, options?: any): void;
+            dir(obj: any, options?: import("util").InspectOptions): void;
+            dirxml(...data: any[]): void;
+            dirxml(...data: any[]): void;
+            error(...data: any[]): void;
+            error(message?: any, ...optionalParams: any[]): void;
+            group(...data: any[]): void;
+            group(...label: any[]): void;
+            groupCollapsed(...data: any[]): void;
+            groupCollapsed(...label: any[]): void;
+            groupEnd(): void;
+            groupEnd(): void;
+            info(...data: any[]): void;
+            info(message?: any, ...optionalParams: any[]): void;
+            log(...data: any[]): void;
+            log(message?: any, ...optionalParams: any[]): void;
+            table(tabularData?: any, properties?: string[]): void;
+            table(tabularData: any, properties?: readonly string[]): void;
+            time(label?: string): void;
+            time(label?: string): void;
+            timeEnd(label?: string): void;
+            timeEnd(label?: string): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeStamp(label?: string): void;
+            timeStamp(label?: string): void;
+            trace(...data: any[]): void;
+            trace(message?: any, ...optionalParams: any[]): void;
+            warn(...data: any[]): void;
+            warn(message?: any, ...optionalParams: any[]): void;
+            Console: console.ConsoleConstructor;
+            profile(label?: string): void;
+            profileEnd(label?: string): void;
+        };
+        "__#12@#userLoggerWithOverridenMethods": any;
+        logLevel: string;
+        step(strings: any, ...values: any[]): void;
+        getLogs(context: string): string[];
+        "__#12@#stringifyLogs"(...args: any[]): string;
+        _templateLiteralLog(strings: any, ...args: any[]): void;
+        "__#12@#logWrapper"(argsArray: any, level: any): void;
+        assert(...args: any[]): void;
+        debug(...args: any[]): void;
+        error(...args: any[]): void;
+        info(...args: any[]): void;
+        log(...args: any[]): void;
+        trace(...args: any[]): void;
+        warn(...args: any[]): void;
+        intercept(userLogger: any): void;
+        stopInterception(): void;
+        configure(config?: {
+            logLevel?: string;
+            prettyObjects?: boolean;
+        }): void;
+        prettyObjects: boolean;
+    };
+    let artifact: (data: string | {
+        path: string;
+        type: string;
+        name: string;
+    }, context?: any) => void;
+    let log: (...args: any[]) => void;
+    let logger: {
+        "__#12@#originalUserLogger": {
+            assert(condition?: boolean, ...data: any[]): void;
+            assert(value: any, message?: string, ...optionalParams: any[]): void;
+            clear(): void;
+            clear(): void;
+            count(label?: string): void;
+            count(label?: string): void;
+            countReset(label?: string): void;
+            countReset(label?: string): void;
+            debug(...data: any[]): void;
+            debug(message?: any, ...optionalParams: any[]): void;
+            dir(item?: any, options?: any): void;
+            dir(obj: any, options?: import("util").InspectOptions): void;
+            dirxml(...data: any[]): void;
+            dirxml(...data: any[]): void;
+            error(...data: any[]): void;
+            error(message?: any, ...optionalParams: any[]): void;
+            group(...data: any[]): void;
+            group(...label: any[]): void;
+            groupCollapsed(...data: any[]): void;
+            groupCollapsed(...label: any[]): void;
+            groupEnd(): void;
+            groupEnd(): void;
+            info(...data: any[]): void;
+            info(message?: any, ...optionalParams: any[]): void;
+            log(...data: any[]): void;
+            log(message?: any, ...optionalParams: any[]): void;
+            table(tabularData?: any, properties?: string[]): void;
+            table(tabularData: any, properties?: readonly string[]): void;
+            time(label?: string): void;
+            time(label?: string): void;
+            timeEnd(label?: string): void;
+            timeEnd(label?: string): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeLog(label?: string, ...data: any[]): void;
+            timeStamp(label?: string): void;
+            timeStamp(label?: string): void;
+            trace(...data: any[]): void;
+            trace(message?: any, ...optionalParams: any[]): void;
+            warn(...data: any[]): void;
+            warn(message?: any, ...optionalParams: any[]): void;
+            Console: console.ConsoleConstructor;
+            profile(label?: string): void;
+            profileEnd(label?: string): void;
+        };
+        "__#12@#userLoggerWithOverridenMethods": any;
+        logLevel: string;
+        step(strings: any, ...values: any[]): void;
+        getLogs(context: string): string[];
+        "__#12@#stringifyLogs"(...args: any[]): string;
+        _templateLiteralLog(strings: any, ...args: any[]): void;
+        "__#12@#logWrapper"(argsArray: any, level: any): void;
+        assert(...args: any[]): void;
+        debug(...args: any[]): void;
+        error(...args: any[]): void;
+        info(...args: any[]): void;
+        log(...args: any[]): void;
+        trace(...args: any[]): void;
+        warn(...args: any[]): void;
+        intercept(userLogger: any): void;
+        stopInterception(): void;
+        configure(config?: {
+            logLevel?: string;
+            prettyObjects?: boolean;
+        }): void;
+        prettyObjects: boolean;
+    };
+    let meta: (keyValue: {
+        [key: string]: string;
+    } | string, value?: string | null) => void;
+    let step: (message: string) => void;
+}
+export default _default;

package/lib/services/artifacts.d.ts

@@ -0,0 +1,33 @@
+export const artifactStorage: ArtifactStorage;
+/**
+ * Artifact storage is supposed to store file paths
+ */
+declare class ArtifactStorage {
+    static "__#13@#instance": any;
+    /**
+     * Singleton
+     * @returns {ArtifactStorage}
+     */
+    static getInstance(): ArtifactStorage;
+    /**
+     * Stores path to file as artifact and uploads it to the S3 storage
+     * @param {string | {path: string, type: string, name: string}} data - path to file or object with path, type and name
+     * @param {*} context testId or test title
+     */
+    put(data: string | {
+        path: string;
+        type: string;
+        name: string;
+    }, context?: any): void;
+    /**
+     * Returns list of artifacts to upload
+     * @param {*} context testId or test context from test runner
+     * @returns {(string | {path: string, type: string, name: string})[]}
+     */
+    get(context: any): (string | {
+        path: string;
+        type: string;
+        name: string;
+    })[];
+}
+export {};

package/lib/services/index.d.ts

@@ -0,0 +1,9 @@
+export namespace services {
+    export { logger };
+    export { artifactStorage as artifacts };
+    export { keyValueStorage as keyValues };
+    export function setContext(context: any): void;
+}
+import { logger } from './logger.js';
+import { artifactStorage } from './artifacts.js';
+import { keyValueStorage } from './key-values.js';

package/lib/services/key-values.d.ts

@@ -0,0 +1,27 @@
+export const keyValueStorage: KeyValueStorage;
+declare class KeyValueStorage {
+    static "__#14@#instance": any;
+    /**
+     *
+     * @returns {KeyValueStorage}
+     */
+    static getInstance(): KeyValueStorage;
+    /**
+     * Stores key-value pair and passes it to reporter
+     * @param {{[key: string]: string}} keyValue - key-value pair(s) as object
+     * @param {*} context - full test title
+     */
+    put(keyValue: {
+        [key: string]: string;
+    }, context?: any): void;
+    /**
+     * Returns key-values pairs for the test as object
+     * @param {*} context testId or test context from test runner
+     * @returns {{[key: string]: string} | {}} key-values pairs as object, e.g. {priority: 'high', browser: 'chrome'}
+     */
+    get(context?: any): {
+        [key: string]: string;
+    } | {};
+    #private;
+}
+export {};

package/lib/services/logger.d.ts

@@ -0,0 +1,64 @@
+export const logger: Logger;
+/**
+ * Logger allows to intercept logs from any logger (console.log, tracer, pino, etc)
+ * and save in the testomatio reporter.
+ * Supports different syntaxes to satisfy any user preferences.
+ */
+declare class Logger {
+    static "__#12@#instance": any;
+    /**
+     *
+     * @returns {Logger}
+     */
+    static getInstance(): Logger;
+    logLevel: string;
+    /**
+     * Allows you to define a step inside a test. Step name is attached to the report and
+     * helps to understand the test flow.
+     * @param {*} strings
+     * @param  {...any} values
+     */
+    step(strings: any, ...values: any[]): void;
+    /**
+     *
+     * @param {string} context testId or test context from test runner
+     * @returns {string[]}
+     */
+    getLogs(context: string): string[];
+    /**
+     * Tagget template literal. Allows to use different syntaxes:
+     * 1. Tagget template: log`text ${someVar}`
+     * 2. Standard: log(`text ${someVar}`)
+     * 3. Standard with multiple arguments: log('text', someVar)
+     */
+    _templateLiteralLog(strings: any, ...args: any[]): void;
+    assert(...args: any[]): void;
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    trace(...args: any[]): void;
+    warn(...args: any[]): void;
+    /**
+     * Intercepts user logger messages.
+     * When call this method, Logger start to control the user logger
+     * @param {*} userLogger
+     */
+    intercept(userLogger: any): void;
+    stopInterception(): void;
+    /**
+     * Allows to configure logger. Make sure you do it before the logger usage in your code.
+     *
+     * @param {Object} [config={}] - The configuration object.
+     * @param {string} [config.logLevel] - The desired log level. Valid values are 'DEBUG', 'INFO', 'WARN', and 'ERROR'.
+     * @param {boolean} [config.prettyObjects] - Specifies whether to enable pretty printing of objects.
+     * @returns {void}
+     */
+    configure(config?: {
+        logLevel?: string;
+        prettyObjects?: boolean;
+    }): void;
+    prettyObjects: boolean;
+    #private;
+}
+export {};

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/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/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

@@ -127,12 +127,9 @@ const fetchIdFromCode = (code, opts = {}) => {
 };
 
 const fetchIdFromOutput = output => {
-  const lines = output
-    .split('\n')
-    .map(l => l.trim())
-    .filter(l => l.startsWith('tid://'));
+  const TID_FULL_PATTERN = new RegExp(`tid:\\/\\/.*?(${TEST_ID_REGEX.source})`);
 
-  return lines.find(c => c.match(TEST_ID_REGEX))?.match(TEST_ID_REGEX)?.[1];
+  return output.match(TID_FULL_PATTERN)?.[2];
 };
 
 const fetchSourceCode = (contents, opts = {}) => {