@testomatio/reporter 2.19.0 → 2.21.0

package/lib/adapter/codecept.js

@@ -16,13 +16,14 @@ const step_formatter_js_1 = require("./utils/step-formatter.js");
 const codeceptjs_1 = __importDefault(require("codeceptjs"));
 const log_js_1 = require("../utils/log.js");
 const debug = (0, debug_1.default)('@testomatio/reporter:adapter:codeceptjs');
+global.TESTOMATIO_ADAPTER = 'codeceptjs';
 // @ts-ignore
 if (!global.codeceptjs) {
     // @ts-ignore
     global.codeceptjs = codeceptjs_1.default;
 }
 // @ts-ignore
-const { event, recorder, codecept, output } = global.codeceptjs;
+const { event, recorder, codecept, output, container } = global.codeceptjs;
 const [, MAJOR_VERSION, MINOR_VERSION] = codecept
     .version()
     .match(/(\d+)\.(\d+)/)
@@ -51,6 +52,7 @@ function CodeceptReporter(config) {
     const reportTestPromises = [];
     let isRunFinalized = false;
     const testTimeMap = {};
+    const failedUrls = new Map();
     const clientConfig = buildCodeceptClientConfig(config);
     const client = new client_js_1.default(clientConfig);
     // Store original output methods for fallback
@@ -211,6 +213,24 @@ function CodeceptReporter(config) {
             await finalizeRun('all.after');
         }, true);
     });
+    event.dispatcher.on(event.test.failed, (test, _err, hookName) => {
+        // no browser in suite hooks
+        if (hookName === 'BeforeSuite' || hookName === 'AfterSuite')
+            return;
+        const helper = Object.values(container.helpers()).find(h => typeof h.grabCurrentUrl === 'function');
+        if (!helper)
+            return;
+        recorder.add('url of failed test', async () => {
+            try {
+                const url = await helper.grabCurrentUrl();
+                if (url)
+                    failedUrls.set(test.uid, url);
+            }
+            catch (err) {
+                debug('Failed to grab url of failed test', err?.message || err);
+            }
+        }, true);
+    });
     event.dispatcher.on(event.test.skipped, test => {
         const { uid, tags, title } = test.simplify();
         if (uid && reportedTestUids.has(uid))
@@ -239,6 +259,10 @@ function CodeceptReporter(config) {
         const keyValues = index_js_1.services.keyValues.get(test.fullTitle());
         const links = index_js_1.services.links.get(test.fullTitle());
         const screenshotOnFailPath = artifacts.screenshot || null;
+        const meta = { ...keyValues, ...test.meta };
+        if (test.state === constants_js_1.STATUS.FAILED && failedUrls.has(uid))
+            meta.failedUrl = failedUrls.get(uid);
+        failedUrls.delete(uid);
         // Build step hierarchy with screenshot from screenshotOnFail
         const stepHierarchy = buildUnifiedStepHierarchy(test.steps, hookSteps, screenshotOnFailPath);
         index_js_1.services.setContext(null);
@@ -255,7 +279,7 @@ function CodeceptReporter(config) {
             logs,
             links,
             manuallyAttachedArtifacts,
-            meta: { ...keyValues, ...test.meta },
+            meta,
         });
         reportTestPromises.push(reportTestPromise);
         processArtifactsForUpload(artifacts, uid, title, videos, traces);

package/lib/adapter/cucumber/current.js

@@ -12,6 +12,7 @@ const client_js_1 = __importDefault(require("../../client.js"));
 const utils_js_1 = require("../../utils/utils.js");
 const config_js_1 = require("../../config.js");
 const index_js_1 = require("../../services/index.js");
+global.TESTOMATIO_ADAPTER = 'cucumber';
 const { GherkinDocumentParser, PickleParser } = cucumber_1.formatterHelpers;
 const { getGherkinScenarioLocationMap, getGherkinStepMap } = GherkinDocumentParser;
 const { getPickleStepMap } = PickleParser;

package/lib/adapter/cypress-plugin/index.js

@@ -7,6 +7,7 @@ const constants_js_1 = require("../../constants.js");
 const utils_js_1 = require("../../utils/utils.js");
 const client_js_1 = __importDefault(require("../../client.js"));
 const config_js_1 = require("../../config.js");
+global.TESTOMATIO_ADAPTER = 'cypress';
 const testomatioReporter = on => {
     if (!config_js_1.config.TESTOMATIO) {
         console.log('TESTOMATIO key is empty, ignoring reports');

package/lib/adapter/e2e.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Reporter for the e2e framework (https://github.com/tester-army/e2e).
+ * Add it to `reporters` in `e2e.config.ts`: `reporters: ['list', testomatio()]`.
+ *
+ * The config is loaded by every worker, so the client is created only inside
+ * handlers, which run in the runner process.
+ *
+ * @param {{ apiKey?: string }} [options]
+ */
+export function testomatio(options?: {
+    apiKey?: string;
+}): {
+    name: string;
+    onEvent(event: any): void;
+    onRunFinished(run: any, signal: any): Promise<{
+        label: string;
+        text: any;
+    }[]>;
+};
+/**
+ * Converts one report-1 result into Testomat.io test data.
+ * Only the final attempt is reported; earlier attempts are counted as retries.
+ */
+export function toTestData(result: any, groups: any, artifactsRoot: any): {
+    status: string;
+    data: {
+        rid: any;
+        title: any;
+        suite_title: string;
+        file: any;
+        test_id: string;
+        tags: any;
+        time: any;
+        timestamp: number;
+        error: Error & {
+            expected?: string;
+            actual?: string;
+        };
+        steps: any;
+        logs: string;
+        files: any[];
+        meta: {
+            target: any;
+            platform: any;
+            browser: any;
+        };
+    };
+};
+export default testomatio;

package/lib/adapter/e2e.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testomatio = testomatio;
+exports.toTestData = toTestData;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const client_js_1 = __importDefault(require("../client.js"));
+const constants_js_1 = require("../constants.js");
+const utils_js_1 = require("../utils/utils.js");
+const step_formatter_js_1 = require("./utils/step-formatter.js");
+const log_js_1 = require("../utils/log.js");
+const debug = (0, debug_1.default)('@testomatio/reporter:adapter-e2e');
+/**
+ * Reporter for the e2e framework (https://github.com/tester-army/e2e).
+ * Add it to `reporters` in `e2e.config.ts`: `reporters: ['list', testomatio()]`.
+ *
+ * The config is loaded by every worker, so the client is created only inside
+ * handlers, which run in the runner process.
+ *
+ * @param {{ apiKey?: string }} [options]
+ */
+function testomatio(options = {}) {
+    let client = null;
+    let runPromise = null;
+    function getClient() {
+        if (!client)
+            client = new client_js_1.default({ apiKey: options.apiKey });
+        return client;
+    }
+    function startRun() {
+        if (!runPromise) {
+            runPromise = getClient()
+                .createRun()
+                .catch(err => log_js_1.log.error('Failed to create Testomat.io run:', err?.message || err));
+        }
+        return runPromise;
+    }
+    return {
+        name: 'testomatio',
+        onEvent(event) {
+            try {
+                if (event?.type === 'run-started')
+                    startRun();
+            }
+            catch (err) {
+                debug('onEvent failed', err);
+            }
+        },
+        async onRunFinished(run, signal) {
+            const reporter = getClient();
+            await startRun();
+            const { report, artifactsRoot } = run;
+            const groups = new Map((report.run.serialGroups || []).map(group => [group.id, group]));
+            const promises = [];
+            for (const result of report.run.results) {
+                if (signal?.aborted)
+                    break;
+                // results left out by `--last-failed` belong to the previous run
+                if (result.selected === false)
+                    continue;
+                const { status, data } = toTestData(result, groups, artifactsRoot);
+                promises.push(reporter.addTestRun(status, data));
+            }
+            await Promise.all(promises);
+            const duration = (Date.parse(report.run.finishedAt) - Date.parse(report.run.startedAt)) / 1000;
+            await reporter.updateRunStatus(runStatus(report.run.status), { duration });
+            const runUrl = reporter.pipeStore?.runUrl;
+            if (runUrl)
+                return [{ label: 'Testomat.io', text: runUrl }];
+        },
+    };
+}
+/**
+ * Converts one report-1 result into Testomat.io test data.
+ * Only the final attempt is reported; earlier attempts are counted as retries.
+ */
+function toTestData(result, groups, artifactsRoot) {
+    const attempts = attemptsOf(result, groups);
+    const final = attempts.at(-1);
+    const titlePath = [...result.titlePath];
+    const title = titlePath.pop();
+    let suiteTitle = titlePath.join(' › ');
+    if (!suiteTitle)
+        suiteTitle = path_1.default.basename(result.file);
+    const meta = {
+        target: result.targetId,
+        platform: result.platform,
+        browser: final?.environment?.browser,
+    };
+    if (result.agent && result.agent !== 'default')
+        meta.agent = result.agent;
+    if (result.repeat)
+        meta.repeat = result.repeat;
+    if (attempts.length > 1)
+        meta.retryCount = attempts.length - 1;
+    if (result.status === 'flaky')
+        meta.isFlaky = true;
+    const status = testStatus(result.status);
+    if (status === constants_js_1.STATUS.FAILED && final?.failure?.url)
+        meta.failedUrl = final.failure.url;
+    const filesById = new Map();
+    for (const artifact of final?.artifacts || []) {
+        if (artifact.path) {
+            filesById.set(artifact.id, {
+                path: path_1.default.join(artifactsRoot, artifact.path),
+                type: artifact.mediaType,
+                title: artifact.kind,
+            });
+        }
+        else if (artifact.url) {
+            // hosted engines keep videos remotely
+            meta[artifact.kind] = artifact.url;
+        }
+    }
+    const files = [...filesById.values()];
+    const steps = (final?.steps || []).map(step => toStep(step, filesById));
+    const data = {
+        rid: result.id,
+        title,
+        suite_title: suiteTitle,
+        file: result.file,
+        test_id: (0, utils_js_1.getTestomatIdFromTestTitle)(title),
+        tags: result.tags || [],
+        time: final?.durationMs || 0,
+        timestamp: timestampOf(final),
+        error: toError(final?.error, final?.secondaryErrors),
+        steps: steps.length ? steps : undefined,
+        logs: logsOf(result, final),
+        files: files.length ? files : undefined,
+        meta,
+    };
+    return { status, data };
+}
+/** Attempts of a result; a serial member keeps its part of the group's attempts. */
+function attemptsOf(result, groups) {
+    if (!result.serialGroupId)
+        return result.attempts || [];
+    const groupAttempts = groups.get(result.serialGroupId)?.attempts || [];
+    return groupAttempts.map(attempt => {
+        const member = attempt.members?.find(candidate => candidate.testId === result.testId);
+        return {
+            status: member?.status || attempt.status,
+            error: member?.error || attempt.error,
+            failure: member?.failure || attempt.failure,
+            steps: member?.steps || [],
+            appLog: member?.appLog || [],
+            skip: member?.skip,
+            durationMs: member?.durationMs,
+            startedAt: member?.startedAt || attempt.startedAt,
+            artifacts: attempt.artifacts || [],
+            secondaryErrors: [...(member?.secondaryErrors || []), ...(attempt.secondaryErrors || [])],
+            environment: attempt.environment,
+        };
+    });
+}
+function timestampOf(attempt) {
+    if (!attempt?.startedAt)
+        return undefined;
+    return Date.parse(attempt.startedAt);
+}
+function testStatus(status) {
+    if (status === 'passed' || status === 'flaky')
+        return constants_js_1.STATUS.PASSED;
+    if (status === 'skipped')
+        return constants_js_1.STATUS.SKIPPED;
+    // failed, timed-out, interrupted: the test reached no passing verdict
+    return constants_js_1.STATUS.FAILED;
+}
+function runStatus(status) {
+    if (status === 'passed')
+        return constants_js_1.STATUS.PASSED;
+    return constants_js_1.STATUS.FAILED;
+}
+function toError(error, secondaryErrors = []) {
+    if (!error)
+        return undefined;
+    /** @type {Error & { expected?: string, actual?: string }} */
+    const err = new Error(error.message);
+    err.name = error.code;
+    err.stack = `${error.code}: ${error.message}\n${error.stack || sourceFrame(error.source)}`;
+    if (error.details?.expected && error.details?.observed) {
+        err.expected = error.details.expected;
+        err.actual = error.details.observed;
+    }
+    for (const secondary of secondaryErrors) {
+        err.stack += `\n\nAlso failed (${secondary.phase || secondary.category}) ${secondary.code}: ${secondary.message}`;
+    }
+    return err;
+}
+function sourceFrame(source) {
+    if (!source)
+        return '';
+    return `    at ${source.file}:${source.line}:${source.column}`;
+}
+function toStep(step, filesById) {
+    let category = 'user';
+    if (step.phase === 'beforeEach' || step.phase === 'afterEach')
+        category = 'hook';
+    let title = step.api;
+    if (step.label)
+        title = `${step.api} ${step.label}`;
+    const formatted = (0, step_formatter_js_1.formatStep)({
+        category,
+        title,
+        duration: step.durationMs,
+        log: stepLog(step),
+    });
+    let status = 'failed';
+    if (step.status === 'passed')
+        status = 'passed';
+    (0, step_formatter_js_1.addStatusToStep)(formatted, status, step.error);
+    if (step.error) {
+        formatted.error = { message: (0, utils_js_1.truncate)(`${step.error.code}: ${step.error.message}`, 250) };
+    }
+    if (constants_js_1.SCREENSHOTS_ON_STEPS) {
+        const screenshot = (step.artifacts || []).map(id => filesById.get(id)).find(file => file?.type === 'image/png');
+        if (screenshot)
+            (0, step_formatter_js_1.addArtifactsToStep)(formatted, { screenshot: screenshot.path });
+    }
+    return formatted;
+}
+/** Agent reasoning and non-binary step statuses, which a passed/failed step would lose. */
+function stepLog(step) {
+    const lines = [];
+    if (step.status !== 'passed' && step.status !== 'failed')
+        lines.push(`status: ${step.status}`);
+    if (step.explanation)
+        lines.push(step.explanation);
+    for (const event of step.events || []) {
+        if (event.reasoning)
+            lines.push(event.reasoning);
+    }
+    return lines.join('\n');
+}
+function logsOf(result, final) {
+    const lines = [];
+    const skip = final?.skip || result.skip;
+    if (skip)
+        lines.push(`Skipped (${skip.cause}): ${skip.reason}`);
+    if (final?.appLog?.length) {
+        lines.push('App log:');
+        for (const line of final.appLog)
+            lines.push(`[${line.source}] ${line.level}: ${line.text}`);
+    }
+    return lines.join('\n');
+}
+module.exports = testomatio;
+
+module.exports.testomatio = testomatio;
+
+module.exports.toTestData = toTestData;

package/lib/adapter/jasmine.js

@@ -7,6 +7,7 @@ exports.JasmineReporter = void 0;
 const client_js_1 = __importDefault(require("../client.js"));
 const utils_js_1 = require("../utils/utils.js");
 const constants_js_1 = require("../constants.js");
+global.TESTOMATIO_ADAPTER = 'jasmine';
 class JasmineReporter {
     constructor(options) {
         this.testTimeMap = {};

package/lib/adapter/jest.js

@@ -12,6 +12,7 @@ const index_js_1 = require("../services/index.js");
 const path_1 = __importDefault(require("path"));
 const debug_1 = __importDefault(require("debug"));
 const debug = (0, debug_1.default)('@testomatio/reporter:adapter-jest');
+global.TESTOMATIO_ADAPTER = 'jest';
 class JestReporter {
     constructor(globalConfig, options) {
         this._globalConfig = globalConfig;

package/lib/adapter/mocha.d.ts

@@ -1,2 +1,5 @@
 export default MochaReporter;
-declare function MochaReporter(runner: any, opts: any): void;
+declare class MochaReporter extends Mocha.reporters.Base {
+    constructor(runner: any, opts: any);
+}
+import Mocha from 'mocha';