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

package/lib/pipe/github.d.ts

@@ -0,0 +1,30 @@
+export default GitHubPipe;
+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 GitHubPipe
+ * @implements {Pipe}
+ */
+declare class GitHubPipe implements Pipe {
+    constructor(params: any, store?: {});
+    isEnabled: boolean;
+    store: {};
+    tests: any[];
+    token: any;
+    ref: string;
+    repo: string;
+    jobKey: string;
+    hiddenCommentData: string;
+    issue: number;
+    start: Date;
+    prepareRun(): Promise<void>;
+    createRun(): Promise<void>;
+    addTest(test: any): void;
+    finishRun(runParams: any): Promise<void>;
+    octokit: import("@octokit/core").Octokit & {
+        paginate: import("@octokit/plugin-paginate-rest").PaginateInterface;
+    } & import("@octokit/plugin-rest-endpoint-methods/dist-types/generated/method-types.js").RestEndpointMethods & import("@octokit/plugin-rest-endpoint-methods/dist-types/types.js").Api;
+    toString(): string;
+}

package/lib/pipe/github.js

@@ -14,8 +14,8 @@ const utils_js_1 = require("../utils/utils.js");
 const pipe_utils_js_1 = require("../utils/pipe_utils.js");
 const debug = (0, debug_1.default)('@testomatio/reporter:pipe:github');
 /**
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  * @class GitHubPipe
  * @implements {Pipe}
  */

package/lib/pipe/gitlab.d.ts

@@ -0,0 +1,23 @@
+export default GitLabPipe;
+export type Pipe = import("../../types/types.js").Pipe;
+export type TestData = import("../../types/types.js").TestData;
+/**
+ * @class GitLabPipe
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
+ */
+declare class GitLabPipe {
+    constructor(params: any, store?: {});
+    isEnabled: boolean;
+    ENV: NodeJS.ProcessEnv;
+    store: {};
+    tests: any[];
+    token: any;
+    hiddenCommentData: string;
+    prepareRun(): Promise<void>;
+    createRun(): Promise<void>;
+    addTest(test: any): void;
+    finishRun(runParams: any): Promise<void>;
+    toString(): string;
+    updateRun(): void;
+}

package/lib/pipe/gitlab.js

@@ -17,8 +17,8 @@ const debug = (0, debug_1.default)('@testomatio/reporter:pipe:gitlab');
 //! and your pipeline trigger should be merge_request
 /**
  * @class GitLabPipe
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  */
 class GitLabPipe {
     constructor(params, store = {}) {

package/lib/pipe/html.d.ts

@@ -0,0 +1,34 @@
+export default HtmlPipe;
+declare class HtmlPipe {
+    constructor(params: any, store?: {});
+    store: {};
+    title: any;
+    apiKey: any;
+    isHtml: string;
+    isEnabled: boolean;
+    htmlOutputPath: string;
+    fullHtmlOutputPath: string;
+    filenameMsg: string;
+    tests: any[];
+    htmlReportDir: string;
+    htmlReportName: string;
+    templateFolderPath: string;
+    templateHtmlPath: string;
+    createRun(): Promise<void>;
+    updateRun(): void;
+    /**
+     * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+     * @param {import('../../types/types.js').RunData} test - object which includes each test entry.
+     */
+    addTest(test: import("../../types/types.js").RunData): void;
+    finishRun(runParams: any): Promise<void>;
+    /**
+     * Generates an HTML report based on provided test data and a template.
+     * @param {object} opts - Test options used to generate the HTML report:
+     * runParams, tests, outputPath, templatePath
+     * @returns {void} - This function does not return anything.
+     */
+    buildReport(opts: object): void;
+    toString(): string;
+    #private;
+}

package/lib/pipe/html.js

@@ -58,7 +58,7 @@ class HtmlPipe {
     }
     /**
      * Add test data to the result array for saving. As a result of this function, we get a result object to save.
-     * @param {import('../../types').RunData} test - object which includes each test entry.
+     * @param {import('../../types/types.js').RunData} test - object which includes each test entry.
      */
     addTest(test) {
         if (!this.isEnabled)
@@ -106,6 +106,13 @@ class HtmlPipe {
             console.log(picocolors_1.default.blue(msg));
         }
         tests.forEach(test => {
+            // steps could be an array or a string
+            test.steps = Array.isArray(test.steps)
+                ? (test.steps = test.steps
+                    .map(step => (0, utils_js_1.formatStep)(step))
+                    .flat()
+                    .join('\n'))
+                : test.steps;
             if (!test.message?.trim()) {
                 test.message = "This test has no 'message' code";
             }

package/lib/pipe/index.d.ts

@@ -0,0 +1 @@
+export function pipesFactory(params: any, opts: any): Promise<any[]>;

package/lib/pipe/index.js

@@ -37,6 +37,7 @@ const gitlab_js_1 = __importDefault(require("./gitlab.js"));
 const csv_js_1 = __importDefault(require("./csv.js"));
 const html_js_1 = __importDefault(require("./html.js"));
 const bitbucket_js_1 = require("./bitbucket.js");
+const debug_js_1 = require("./debug.js");
 async function pipesFactory(params, opts) {
     const extraPipes = [];
     // Add extra pipes into package.json file:
@@ -72,12 +73,11 @@ async function pipesFactory(params, opts) {
         new csv_js_1.default(params, opts),
         new html_js_1.default(params, opts),
         new bitbucket_js_1.BitbucketPipe(params, opts),
+        new debug_js_1.DebugPipe(params, opts),
         ...extraPipes,
     ];
     const pipesEnabled = pipes.filter(p => p.isEnabled);
-    console.log(constants_js_1.APP_PREFIX, picocolors_1.default.cyan('Pipes:'), picocolors_1.default.cyan(pipesEnabled
-        .map(p => p.toString())
-        .join(', ') || 'No pipes enabled'));
+    console.log(constants_js_1.APP_PREFIX, picocolors_1.default.cyan('Pipes:'), picocolors_1.default.cyan(pipesEnabled.map(p => p.toString()).join(', ') || 'No pipes enabled'));
     if (!pipesEnabled.length) {
         console.log(constants_js_1.APP_PREFIX, picocolors_1.default.dim('If you want to use Testomatio reporter, pass your token as TESTOMATIO env variable'));
     }

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: any;
+    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

@@ -19,8 +19,8 @@ if (process.env.TESTOMATIO_RUN) {
     // process.env.runId = process.env.TESTOMATIO_RUN;
 }
 /**
- * @typedef {import('../../types').Pipe} Pipe
- * @typedef {import('../../types').TestData} TestData
+ * @typedef {import('../../types/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').TestData} TestData
  * @class TestomatioPipe
  * @implements {Pipe}
  */
@@ -59,11 +59,13 @@ class TestomatioPipe {
         this.axios = axios_1.default.create({
             baseURL: `${this.url.trim()}`,
             timeout: constants_js_1.AXIOS_TIMEOUT,
-            proxy: proxy ? {
-                host: proxy.hostname,
-                port: parseInt(proxy.port, 10),
-                protocol: proxy.protocol,
-            } : false,
+            proxy: proxy
+                ? {
+                    host: proxy.hostname,
+                    port: parseInt(proxy.port, 10),
+                    protocol: proxy.protocol,
+                }
+                : false,
         });
         // Pass the axios instance to the retry function
         (0, axios_retry_1.default)(this.axios, {
@@ -97,6 +99,7 @@ class TestomatioPipe {
         this.runId = params.runId || process.env.runId;
         this.createNewTests = params.createNewTests ?? !!process.env.TESTOMATIO_CREATE;
         this.hasUnmatchedTests = false;
+        this.requestFailures = 0;
         if (!(0, utils_js_1.isValidUrl)(this.url.trim())) {
             this.isEnabled = false;
             console.error(constants_js_1.APP_PREFIX, picocolors_1.default.red(`Error creating report on Testomat.io, report url '${this.url}' is invalid`));
@@ -141,10 +144,9 @@ class TestomatioPipe {
      */
     async createRun(params = {}) {
         this.batch.isEnabled = params.isBatchEnabled ?? this.batch.isEnabled;
-        debug('Creating run...');
         if (!this.isEnabled)
             return;
-        if (this.batch.isEnabled)
+        if (this.batch.isEnabled && this.isEnabled)
             this.batch.intervalFunction = setInterval(this.#batchUpload, this.batch.intervalTime);
         let buildUrl = process.env.BUILD_URL || process.env.CI_JOB_URL || process.env.CIRCLE_BUILD_URL;
         // GitHub Actions Url
@@ -177,12 +179,14 @@ class TestomatioPipe {
         }).filter(([, value]) => !!value));
         debug(' >>>>>> Run params', JSON.stringify(runParams, null, 2));
         if (this.runId) {
+            this.store.runId = this.runId;
             debug(`Run with id ${this.runId} already created, updating...`);
             const resp = await this.axios.put(`/api/reporter/${this.runId}`, runParams);
             if (resp.data.artifacts)
                 (0, pipe_utils_js_1.setS3Credentials)(resp.data.artifacts);
             return;
         }
+        debug('Creating run...');
         try {
             const resp = await this.axios.post(`/api/reporter`, runParams, {
                 maxContentLength: Infinity,
@@ -201,37 +205,39 @@ class TestomatioPipe {
             debug('Run created', this.runId);
         }
         catch (err) {
-            console.error(constants_js_1.APP_PREFIX, 'Error creating Testomat.io report, please check if your API key is valid. Skipping report | ', err?.response?.statusText || err?.status || err.message);
+            const errorText = err.response?.data?.message || err.message;
+            console.log(errorText || err);
+            if (!this.apiKey)
+                console.error('Testomat.io API key is not set');
+            if (!this.apiKey?.startsWith('tstmt'))
+                console.error('Testomat.io API key is invalid');
+            console.error(constants_js_1.APP_PREFIX, 'Error creating Testomat.io report (see details above), please check if your API key is valid. Skipping report');
             printCreateIssue(err);
         }
         debug('"createRun" function finished');
     }
     /**
      * Decides whether to skip test reporting in case of too many request failures
-     * @param {TestData} testData
      * @returns {boolean}
      */
-    #cancelTestReportingInCaseOfTooManyReqFailures(testData) {
-        if (this.reportingCanceledDueToReqFailures)
-            return true;
-        const retriesCountWithinTime = this.retriesTimestamps.filter(timestamp => Date.now() - timestamp < constants_js_1.REPORTER_REQUEST_RETRIES.withinTimeSeconds * 1000).length;
-        debug(`${retriesCountWithinTime} failed requests within ${constants_js_1.REPORTER_REQUEST_RETRIES.withinTimeSeconds}s`);
-        if (retriesCountWithinTime > constants_js_1.REPORTER_REQUEST_RETRIES.maxTotalRetries) {
-            const errorMessage = picocolors_1.default.yellow(`${retriesCountWithinTime} requests were failed within ${constants_js_1.REPORTER_REQUEST_RETRIES.withinTimeSeconds}s,\
- reporting for test "${testData.title}" to Testomat is skipped`);
-            console.warn(`${constants_js_1.APP_PREFIX} ${errorMessage}`);
+    #cancelTestReportingInCaseOfTooManyReqFailures() {
+        if (!process.env.TESTOMATIO_MAX_REQUEST_FAILURES)
+            return;
+        const cancelReporting = this.requestFailures >= parseInt(process.env.TESTOMATIO_MAX_REQUEST_FAILURES, 10);
+        if (cancelReporting) {
             this.reportingCanceledDueToReqFailures = true;
-            this.notReportedTestsCount++;
-            return true;
+            let errorMessage = `⚠️ ${process.env.TESTOMATIO_MAX_REQUEST_FAILURES}`;
+            errorMessage += ' requests were failed, reporting to Testomat aborted.';
+            console.warn(`${constants_js_1.APP_PREFIX} ${picocolors_1.default.yellow(errorMessage)}`);
         }
-        return false;
+        return cancelReporting;
     }
     #uploadSingleTest = async (data) => {
         if (!this.isEnabled)
             return;
         if (!this.runId)
             return;
-        if (this.#cancelTestReportingInCaseOfTooManyReqFailures(data))
+        if (this.#cancelTestReportingInCaseOfTooManyReqFailures())
             return;
         data.api_key = this.apiKey;
         data.create = this.createNewTests;
@@ -240,9 +246,9 @@ class TestomatioPipe {
         }
         const json = json_cycle_1.default.stringify(data);
         debug('Adding test', json);
-        return this.axios
-            .post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig)
-            .catch(err => {
+        return this.axios.post(`/api/reporter/${this.runId}/testrun`, json, axiosAddTestrunRequestConfig).catch(err => {
+            this.requestFailures++;
+            this.notReportedTestsCount++;
             if (err.response) {
                 if (err.response.status >= 400) {
                     const responseData = err.response.data || { message: '' };
@@ -266,6 +272,10 @@ class TestomatioPipe {
     #batchUpload = async () => {
         if (!this.batch.isEnabled)
             return;
+        if (!this.batch.tests.length)
+            return;
+        if (this.#cancelTestReportingInCaseOfTooManyReqFailures())
+            return;
         // prevent infinite loop
         if (this.batch.numberOfTimesCalledWithoutTests > 10) {
             debug('📨 Batch upload: no tests to send for 10 times, stopping batch');
@@ -284,6 +294,8 @@ class TestomatioPipe {
         return this.axios
             .post(`/api/reporter/${this.runId}/testrun`, { api_key: this.apiKey, tests: testsToSend, batch_index: this.batch.batchIndex }, axiosAddTestrunRequestConfig)
             .catch(err => {
+            this.requestFailures++;
+            this.notReportedTestsCount += testsToSend.length;
             if (err.response) {
                 if (err.response.status >= 400) {
                     const responseData = err.response.data || { message: '' };
@@ -323,15 +335,21 @@ class TestomatioPipe {
             this.#batchUpload();
     }
     /**
-     * @param {import('../../types').RunData} params
+     * @param {import('../../types/types.js').RunData} params
      * @returns
      */
     async finishRun(params) {
         if (!this.isEnabled)
             return;
-        if (this.batch.intervalFunction)
-            clearInterval(this.batch.intervalFunction);
         await this.#batchUpload();
+        if (this.batch.intervalFunction) {
+            clearInterval(this.batch.intervalFunction);
+            // this code is required in case test is added after run is finished
+            // (e.g. if test has artifacts, add test function will be invoked only after artifacts are uploaded)
+            // batch stops working after run is finished; thus, disable it to use single test uploading
+            this.batch.intervalFunction = null;
+            this.batch.isEnabled = false;
+        }
         debug('Finishing run...');
         if (this.reportingCanceledDueToReqFailures) {
             const errorMessage = picocolors_1.default.red(`⚠️ Due to request failures, ${this.notReportedTestsCount} test(s) were not reported to Testomat.io`);
@@ -351,7 +369,9 @@ class TestomatioPipe {
             if (this.runId && !this.proceed) {
                 await this.axios.put(`/api/reporter/${this.runId}`, {
                     api_key: this.apiKey,
+                    duration: params.duration,
                     status_event,
+                    detach: params.detach,
                     tests: params.tests,
                 });
                 if (this.runUrl) {

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-functions.js

@@ -1,37 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("./services/index.js");
-const playwright_js_1 = require("./adapter/playwright.js");
-if (process.env.PLAYWRIGHT_TEST_BASE_URL)
-    (0, playwright_js_1.initPlaywrightForStorage)();
 /**
  * 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
  */
 function saveArtifact(data, context = null) {
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error(`This function is not available in Playwright framework.
+    /Playwright supports artifacts out of the box`);
     if (!data)
         return;
     index_js_1.services.artifacts.put(data, context);
 }
 /**
  * Attach log message(s) to the test report
- * @param  {...any} args
+ * @param  string
  */
 function logMessage(...args) {
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error('This function is not available in Playwright framework');
     index_js_1.services.logger._templateLiteralLog(...args);
 }
 /**
  * Similar to "log" function but marks message in report as a step
- * @param {*} message
+ * @param {string} message
  */
 function addStep(message) {
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error('This function is not available in Playwright framework. Use playwright steps');
     index_js_1.services.logger.step(message);
 }
 /**
  * Add key-value pair(s) to the test report
- * @param {*} keyValue
+ * @param {{[key: string]: string} | string} keyValue object { key: value } (multiple props allowed) or key (string)
+ * @param {string?} value
  */
-function setKeyValue(keyValue) {
+function setKeyValue(keyValue, value = null) {
+    if (process.env.IS_PLAYWRIGHT)
+        throw new Error('This function is not available in Playwright framework. Use test tag instead.');
+    if (typeof keyValue === 'string') {
+        keyValue = { [keyValue]: value };
+    }
     index_js_1.services.keyValues.put(keyValue);
 }
 module.exports = {