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

package/lib/adapter/codecept.d.ts

@@ -0,0 +1,2 @@
+export default CodeceptReporter;
+export function CodeceptReporter(config: any): void;

package/lib/adapter/cucumber/current.d.ts

@@ -0,0 +1,14 @@
+export default CucumberReporter;
+export class CucumberReporter extends Formatter {
+    constructor(options: any);
+    failures: any[];
+    cases: any[];
+    client: TestomatClient;
+    status: string;
+    parseEnvelope(envelope: any): void;
+    onTestCaseStarted(testCaseStarted: any): void;
+    onTestCaseFinished(testCaseFinished: any): void;
+    onTestRunFinished(envelope: any): void;
+}
+import { Formatter } from '@cucumber/cucumber';
+import TestomatClient from '../../client.js';

package/lib/adapter/cucumber.d.ts

@@ -0,0 +1,2 @@
+export default CucumberReporter;
+import { CucumberReporter } from './cucumber/current.js';

package/lib/adapter/cypress-plugin/index.d.ts

@@ -0,0 +1,2 @@
+export default testomatioReporter;
+declare function testomatioReporter(on: any): void;

package/lib/adapter/jasmine.d.ts

@@ -0,0 +1,11 @@
+export default JasmineReporter;
+export class JasmineReporter {
+    constructor(options: any);
+    testTimeMap: {};
+    client: TestomatClient;
+    getDuration(test: any): number;
+    specStarted(result: any): void;
+    specDone(result: any): void;
+    jasmineDone(suiteInfo: any, done: any): void;
+}
+import TestomatClient from '../client.js';

package/lib/adapter/jest.d.ts

@@ -0,0 +1,13 @@
+export class JestReporter {
+    constructor(globalConfig: any, options: any);
+    _globalConfig: any;
+    _options: any;
+    client: TestomatClient;
+    onRunStart(): void;
+    onTestStart(testFile: any): void;
+    onTestCaseStart(test: any, testCase: any): void;
+    onTestResult(test: any, testResult: any): void;
+    onRunComplete(contexts: any, results: any): void;
+}
+export default JestReporter;
+import TestomatClient from '../client.js';

package/lib/adapter/mocha.d.ts

@@ -0,0 +1,2 @@
+export default MochaReporter;
+declare function MochaReporter(runner: any, opts: any): void;

package/lib/adapter/nightwatch.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function write(results: any, options: any, done: any): Promise<void>;
+}
+export default _default;

package/lib/adapter/nightwatch.js

@@ -0,0 +1,75 @@
+import TestomatClient from '../client.js';
+import { config } from '../config.js';
+import { STATUS } from '../constants';
+import { getTestomatIdFromTestTitle } from '../utils/utils.js';
+const apiKey = config.TESTOMATIO;
+const client = new TestomatClient({ apiKey });
+export default {
+    write: async (results, options, done) => {
+        await client.createRun();
+        const testFiles = results.modules;
+        for (const fileName in testFiles) {
+            // in nightwatch: object containing tests from a single file
+            const testModule = testFiles[fileName];
+            // passed and failed tests (tests with assertions)
+            const completedTests = testModule.completed;
+            // skipped tests (skipped by user or tests without assertions)
+            const skippedTests = testModule.skipped;
+            const tags = testModule.tags || [];
+            // if test file contains multiple suites, the last suite name is used as a name 🤷‍♂️
+            // no other places which contain suite name (even inside test object)
+            const suiteTitle = testModule.name;
+            for (const testTitle in completedTests) {
+                const test = completedTests[testTitle];
+                let status;
+                switch (test.status) {
+                    case 'pass':
+                        status = STATUS.PASSED;
+                        break;
+                    case 'fail':
+                        status = STATUS.FAILED;
+                        break;
+                    // probably not required (because skipped tests are in separate array), but just in case
+                    case 'skip':
+                        status = STATUS.SKIPPED;
+                        console.info('Skipped test is in completed tests array:', test, 'Not expected behavior.');
+                        break;
+                    default:
+                        console.error('Test status processing error:', test.status);
+                }
+                const testId = getTestomatIdFromTestTitle(testTitle);
+                client.addTestRun(status, {
+                    error: { name: test.assertions?.[0]?.name, message: test.assertions?.[0]?.message, stack: test.stackTrace },
+                    file: testModule.modulePath?.replace(process.cwd(), ''),
+                    message: test.assertions?.[0]?.message,
+                    rid: `${testModule.uuid || ''}_${testTitle || ''}`,
+                    stack: test.stackTrace,
+                    suite_title: suiteTitle,
+                    tags,
+                    test_id: testId,
+                    time: test.timeMs,
+                    title: testTitle,
+                });
+            }
+            // just array with skipped tests titles, no any other info
+            for (const testTitle of skippedTests) {
+                client.addTestRun(STATUS.SKIPPED, {
+                    suite_title: suiteTitle,
+                    tags,
+                    rid: `${testModule.uuid || ''}_${testTitle || ''}`,
+                    title: testTitle,
+                });
+            }
+        }
+        /**
+         * @type {'passed' | 'failed' | 'finished'}
+         */
+        let runStatus = 'finished';
+        if (results.failed)
+            runStatus = 'failed';
+        else if (results.passed)
+            runStatus = 'passed';
+        await client.updateRunStatus(runStatus);
+        done();
+    },
+};

package/lib/adapter/playwright.d.ts

@@ -0,0 +1,14 @@
+export default PlaywrightReporter;
+declare class PlaywrightReporter {
+    constructor(config?: {});
+    client: TestomatioClient;
+    uploads: any[];
+    onBegin(config: any, suite: any): void;
+    suite: any;
+    config: any;
+    onTestBegin(testInfo: any): void;
+    onTestEnd(test: any, result: any): void;
+    onEnd(result: any): Promise<void>;
+    #private;
+}
+import TestomatioClient from '../client.js';

package/lib/adapter/vitest.d.ts

@@ -0,0 +1,35 @@
+export default VitestReporter;
+export type VitestTest = any;
+export type VitestTestFile = any;
+export type VitestSuite = any;
+export type VitestTestLogs = any;
+export type ErrorWithDiff = import("../../types/vitest.types.js").ErrorWithDiff;
+export type STATUS = typeof import("../constants.js").STATUS;
+export type TestData = import("../../types/types.js").TestData;
+/**
+ * @typedef {import('../../types/types.js').VitestTest} VitestTest
+ * @typedef {import('../../types/types.js').VitestTestFile} VitestTestFile
+ * @typedef {import('../../types/types.js').VitestSuite} VitestSuite
+ * @typedef {import('../../types/types.js').VitestTestLogs} VitestTestLogs
+ * @typedef {import('../../types/vitest.types.js').ErrorWithDiff} ErrorWithDiff
+ * @typedef {typeof import('../constants.js').STATUS} STATUS
+ * @typedef {import('../../types/types.js').TestData} TestData
+ */
+export class VitestReporter {
+    constructor(config?: {});
+    client: TestomatioClient;
+    /**
+     * @type {(TestData & {status: string})[]} tests
+     */
+    tests: (TestData & {
+        status: string;
+    })[];
+    onInit(): void;
+    /**
+     * @param {VitestTestFile[] | undefined} files // array with results;
+     * @param {unknown[] | undefined} errors // errors does not contain errors from tests; probably its testrunner errors
+     */
+    onFinished(files: VitestTestFile[] | undefined, errors: unknown[] | undefined): Promise<void>;
+    #private;
+}
+import { Client as TestomatioClient } from '../client.js';

package/lib/adapter/webdriver.d.ts

@@ -0,0 +1,24 @@
+export default WebdriverReporter;
+declare class WebdriverReporter extends WDIOReporter {
+    constructor(options: any);
+    client: TestomatClient;
+    _addTestPromises: any[];
+    _isSynchronising: boolean;
+    /**
+     *
+     * @param {RunnerStats} runData
+     */
+    onRunnerEnd(runData: RunnerStats): Promise<void>;
+    onRunnerStart(): void;
+    onTestStart(test: any): void;
+    onTestEnd(test: any): void;
+    onSuiteEnd(scerario: any): void;
+    addTest(test: any): Promise<void>;
+    /**
+     * @param {import('../../types/types.js').WebdriverIOScenario} scenario
+     */
+    addBddScenario(scenario: import("../../types/types.js").WebdriverIOScenario): Promise<import("../../types/types.js").PipeResult[]>;
+}
+import WDIOReporter from '@wdio/reporter';
+import TestomatClient from '../client.js';
+import { RunnerStats } from '@wdio/reporter';

package/lib/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/reportXml.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/startTest.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin/uploadArtifacts.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/client.d.ts

@@ -0,0 +1,76 @@
+export default Client;
+export type TestData = import("../types/types.js").TestData;
+export type PipeResult = import("../types/types.js").PipeResult;
+/**
+ * @typedef {import('../types/types.js').TestData} TestData
+ * @typedef {import('../types/types.js').PipeResult} PipeResult
+ */
+export class Client {
+    /**
+     * Create a Testomat client instance
+     * @returns
+     */
+    constructor(params?: {});
+    paramsForPipesFactory: {};
+    pipeStore: {};
+    runId: `${string}-${string}-${string}-${string}-${string}`;
+    queue: Promise<void>;
+    version: any;
+    executionList: Promise<void>;
+    uploader: S3Uploader;
+    /**
+     * Asynchronously prepares the execution list for running tests through various pipes.
+     * Each pipe in the client is checked for enablement,
+     * and if all pipes are disabled, the function returns a resolved Promise.
+     * Otherwise, it executes the `prepareRun` method for each enabled pipe and collects the results.
+     * The results are then filtered to remove any undefined values.
+     * If no valid results are found, the function returns undefined.
+     * Otherwise, it returns the first non-empty array from the filtered results.
+     *
+     * @param {Object} params - The options for preparing the test execution list.
+     * @param {string} params.pipe - Name of the executed pipe.
+     * @param {string} params.pipeOptions - Filter option.
+     * @returns {Promise<any>} - A Promise that resolves to an
+     * array containing the prepared execution list,
+     * or resolves to undefined if no valid results are found or if all pipes are disabled.
+     */
+    prepareRun(params: {
+        pipe: string;
+        pipeOptions: string;
+    }): Promise<any>;
+    pipes: any[];
+    /**
+     * Used to create a new Test run
+     *
+     * @returns {Promise<any>} - resolves to Run id which should be used to update / add test
+     */
+    createRun(params: any): Promise<any>;
+    /**
+     * Updates test status and its data
+     *
+     * @param {string|undefined} status
+     * @param {TestData} [testData]
+     * @returns {Promise<PipeResult[]>}
+     */
+    addTestRun(status: string | undefined, testData?: TestData): Promise<PipeResult[]>;
+    /**
+     *
+     * Updates the status of the current test run and finishes the run.
+     * @param {'passed' | 'failed' | 'skipped' | 'finished'} status - The status of the current test run.
+     * Must be one of "passed", "failed", or "finished"
+     * @param {boolean} [isParallel] - Whether the current test run was executed in parallel with other tests.
+     * @returns {Promise<any>} - A Promise that resolves when finishes the run.
+     */
+    updateRunStatus(status: "passed" | "failed" | "skipped" | "finished", isParallel?: boolean): Promise<any>;
+    /**
+     * Returns the formatted stack including the stack trace, steps, and logs.
+     * @returns {string}
+     */
+    formatLogs({ error, steps, logs }: {
+        error: any;
+        steps: any;
+        logs: any;
+    }): string;
+    formatError(error: any, message: any): string;
+}
+import { S3Uploader } from './uploader.js';

package/lib/config.d.ts

@@ -0,0 +1 @@
+export const config: NodeJS.ProcessEnv;

package/lib/constants.d.ts

@@ -0,0 +1,25 @@
+export const APP_PREFIX: string;
+export const TESTOMAT_TMP_STORAGE_DIR: string;
+export const CSV_HEADERS: {
+    id: string;
+    title: string;
+}[];
+export namespace STATUS {
+    let PASSED: string;
+    let FAILED: string;
+    let SKIPPED: string;
+    let FINISHED: string;
+}
+export namespace HTML_REPORT {
+    let FOLDER: string;
+    let REPORT_DEFAULT_NAME: string;
+    let TEMPLATE_NAME: string;
+}
+export const AXIOS_TIMEOUT: number;
+export const testomatLogoURL: "https://avatars.githubusercontent.com/u/59105116?s=36&v=4";
+export namespace REPORTER_REQUEST_RETRIES {
+    let retryTimeout: number;
+    let retriesPerRequest: number;
+    let maxTotalRetries: number;
+    let withinTimeSeconds: number;
+}

package/lib/data-storage.d.ts

@@ -0,0 +1,34 @@
+export const dataStorage: DataStorage;
+declare class DataStorage {
+    static "__#11@#instance": any;
+    /**
+     *
+     * @returns {DataStorage}
+     */
+    static getInstance(): DataStorage;
+    context: any;
+    setContext(context: any): void;
+    isFileStorage: boolean;
+    /**
+     * Puts any data to storage (file or global variable).
+     * If file: stores data as text, if global variable – stores as array of data.
+     * @param {'log' | 'artifact' | 'keyvalue'} dataType
+     * @param {*} data anything you want to store (string, object, array, etc)
+     * @param {*} context could be testId or any context (test name, suite name, including their IDs etc)
+     * suite name + test name is used by default
+     * @returns
+     */
+    putData(dataType: "log" | "artifact" | "keyvalue", data: any, context?: any): void;
+    /**
+     * Returns data, stored for specific test/context (or data which was stored without test id specified).
+     * This method will get data from global variable and/or from from file (previosly saved with put method).
+     *
+     * @param {'log' | 'artifact' | 'keyvalue'} dataType
+     * @param {string} context
+     * @returns {any []} array of data (any type), null (if no data found for context) or string (if data type is log)
+     */
+    getData(dataType: "log" | "artifact" | "keyvalue", context: string): any[];
+    #private;
+}
+export function stringToMD5Hash(str: any): string;
+export {};

package/lib/junit-adapter/adapter.d.ts

@@ -0,0 +1,9 @@
+export default Adapter;
+declare class Adapter {
+    constructor(opts: any);
+    opts: any;
+    getFilePath(t: any): any;
+    formatTest(t: any): any;
+    formatStack(t: any): any;
+    formatMessage(t: any): any;
+}

package/lib/junit-adapter/csharp.d.ts

@@ -0,0 +1,5 @@
+export default CSharpAdapter;
+declare class CSharpAdapter extends Adapter {
+    getFilePath(t: any): string;
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/index.d.ts

@@ -0,0 +1,3 @@
+export default AdapterFactory;
+declare function AdapterFactory(lang: any, opts: any): Adapter;
+import Adapter from './adapter.js';

package/lib/junit-adapter/java.d.ts

@@ -0,0 +1,5 @@
+export default JavaAdapter;
+declare class JavaAdapter extends Adapter {
+    getFilePath(t: any): string;
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/javascript.d.ts

@@ -0,0 +1,4 @@
+export default JavaScriptAdapter;
+declare class JavaScriptAdapter extends Adapter {
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/python.d.ts

@@ -0,0 +1,5 @@
+export default PythonAdapter;
+declare class PythonAdapter extends Adapter {
+    getFilePath(t: any): string;
+}
+import Adapter from './adapter.js';

package/lib/junit-adapter/ruby.d.ts

@@ -0,0 +1,4 @@
+export default RubyAdapter;
+declare class RubyAdapter extends Adapter {
+}
+import Adapter from './adapter.js';

package/lib/output.d.ts

@@ -0,0 +1,11 @@
+export default Output;
+declare class Output {
+    constructor(opts?: {});
+    filterFn: any;
+    reset(): void;
+    log: any[];
+    start(): void;
+    push(line: any): void;
+    text(): string;
+    stop(): void;
+}

package/lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/pipe/bitbucket.d.ts

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

package/lib/pipe/csv.d.ts

@@ -0,0 +1,47 @@
+export default CsvPipe;
+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 CsvPipe
+ * @implements {Pipe}
+ */
+declare class CsvPipe implements Pipe {
+    constructor(params: any, store: any);
+    store: any;
+    title: any;
+    results: any[];
+    outputDir: string;
+    defaultReportName: string;
+    csvFilename: string;
+    isEnabled: boolean;
+    outputFile: string;
+    prepareRun(): Promise<void>;
+    createRun(): Promise<void>;
+    updateRun(): void;
+    /**
+     * Create a folder that will contain the exported files
+     */
+    checkExportDir(): void;
+    /**
+     * Save data to the csv file.
+     * @param {Object} data - data that will be added to the CSV file.
+     * Example: [{suite_title: "Suite #1", test: "Test-case-1", message: "Test msg"}]
+     * @param {Object} headers - csv file headers. Example: [{ id: 'suite_title', title: 'Suite_title' }]
+     */
+    saveToCsv(data: any, headers: any): Promise<void>;
+    /**
+     * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+     * @param {Object} test - object which includes each test entry.
+     */
+    addTest(test: any): void;
+    /**
+     * @param {{ tests?: TestData[] }} runParams
+     * @returns {Promise<void>}
+     */
+    finishRun(runParams: {
+        tests?: TestData[];
+    }): Promise<void>;
+    toString(): string;
+}

package/lib/pipe/debug.d.ts

@@ -0,0 +1,29 @@
+export class DebugPipe {
+    constructor(params: any, store: any);
+    params: any;
+    store: any;
+    isEnabled: boolean;
+    batch: {
+        isEnabled: any;
+        intervalFunction: any;
+        intervalTime: number;
+        tests: any[];
+        batchIndex: number;
+    };
+    logFilePath: string;
+    testomatioEnvVars: {};
+    batchUpload(): Promise<void>;
+    /**
+     * Logs data to a file if logging is enabled.
+     *
+     * @param {Object} logData - The data to be logged.
+     * @returns {Promise<void>} A promise that resolves when the log data has been appended to the file.
+     */
+    logToFile(logData: any): Promise<void>;
+    lastActionTimestamp: number;
+    prepareRun(opts: any): Promise<any[]>;
+    createRun(params?: {}): Promise<{}>;
+    addTest(data: any): Promise<void>;
+    finishRun(params: any): Promise<void>;
+    toString(): string;
+}

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 & import("@octokit/plugin-rest-endpoint-methods/dist-types/generated/method-types.js").RestEndpointMethods & import("@octokit/plugin-rest-endpoint-methods").Api & {
+        paginate: import("@octokit/plugin-paginate-rest").PaginateInterface;
+    };
+    toString(): string;
+}

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/html.d.ts

@@ -0,0 +1,35 @@
+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>;
+    prepareRun(): 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/index.d.ts

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