playwright-ctrf-json-reporter 0.0.26 → 0.0.28-next-0

package/README.md

@@ -122,6 +122,7 @@ reporter: [
         repositoryName: "ctrf-json",    // Optional: Specify the repository name.
         repositoryUrl: "https://gh.io", // Optional: Specify the repository url.
         branchName: "main",             // Optional: Specify the branch name.
+        commit: "abc123",               // Optional: Specify the commit id.
         testEnvironment: "staging"      // Optional: Specify the test environment (e.g. staging, production).
     }]
   ],

package/dist/adapter/index.d.ts

@@ -0,0 +1,2 @@
+export { ctrf, extra, CTRF_RUNTIME_MESSAGE_CONTENT_TYPE } from './runtime';
+export type { CtrfRuntimeMessage, CtrfRuntimeMessageType } from './runtime';

package/dist/adapter/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = exports.extra = exports.ctrf = void 0;
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "ctrf", { enumerable: true, get: function () { return runtime_1.ctrf; } });
+Object.defineProperty(exports, "extra", { enumerable: true, get: function () { return runtime_1.extra; } });
+Object.defineProperty(exports, "CTRF_RUNTIME_MESSAGE_CONTENT_TYPE", { enumerable: true, get: function () { return runtime_1.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE; } });

package/dist/adapter/runtime.d.ts

@@ -0,0 +1,66 @@
+/**
+ * CTRF Runtime API for Playwright
+ *
+ * Enables enriching CTRF test reports with custom metadata at runtime.
+ * Metadata is collected via Playwright's native attachment mechanism and
+ * consolidated by the reporter into the test's `extra` field.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ctrf } from 'playwright-ctrf-json-reporter'
+ *
+ * test('checkout flow', async ({ page }) => {
+ *   ctrf.extra({ owner: 'checkout-team', priority: 'P1' })
+ *   // ... test code
+ *   ctrf.extra({ customMetric: calculateValue() })
+ * })
+ * ```
+ *
+ * ## API
+ *
+ * - `ctrf.extra(data)` - Attach key-value metadata to the current test
+ *
+ * ## Behavior
+ *
+ * - Call multiple times; all data is collected and merged
+ * - Works from any function in the call stack during test execution
+ * - Silently ignored when called outside test context
+ * - Shallow merge: keys from later calls overwrite earlier ones
+ */
+/**
+ * Content type used to identify CTRF runtime messages in attachments.
+ * The reporter will look for attachments with this content type.
+ */
+export declare const CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = "application/vnd.ctrf.message+json";
+/**
+ * Runtime message types
+ */
+export type CtrfRuntimeMessageType = 'metadata';
+/**
+ * A runtime message sent from test code to the reporter
+ */
+export interface CtrfRuntimeMessage {
+    type: CtrfRuntimeMessageType;
+    data: Record<string, unknown>;
+}
+/**
+ * Attach custom metadata to the current test.
+ *
+ * @param data - Key-value pairs to include in the CTRF report's `extra` field
+ * @returns Promise (can be ignored; completes when attachment is written)
+ *
+ * @remarks
+ * - Multiple calls accumulate; later keys overwrite earlier ones (shallow merge)
+ * - Safe to call from helper functions - binds to the active test automatically
+ * - No-op outside test context (e.g., in global setup)
+ *
+ * @example
+ * ctrf.extra({ owner: 'platform-team' })
+ * ctrf.extra({ executionId: uuid(), retryable: true })
+ */
+export declare function extra(data: Record<string, unknown>): Promise<void>;
+/** CTRF runtime API namespace */
+export declare const ctrf: {
+    readonly extra: typeof extra;
+};

package/dist/adapter/runtime.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * CTRF Runtime API for Playwright
+ *
+ * Enables enriching CTRF test reports with custom metadata at runtime.
+ * Metadata is collected via Playwright's native attachment mechanism and
+ * consolidated by the reporter into the test's `extra` field.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ctrf } from 'playwright-ctrf-json-reporter'
+ *
+ * test('checkout flow', async ({ page }) => {
+ *   ctrf.extra({ owner: 'checkout-team', priority: 'P1' })
+ *   // ... test code
+ *   ctrf.extra({ customMetric: calculateValue() })
+ * })
+ * ```
+ *
+ * ## API
+ *
+ * - `ctrf.extra(data)` - Attach key-value metadata to the current test
+ *
+ * ## Behavior
+ *
+ * - Call multiple times; all data is collected and merged
+ * - Works from any function in the call stack during test execution
+ * - Silently ignored when called outside test context
+ * - Shallow merge: keys from later calls overwrite earlier ones
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ctrf = exports.extra = exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = void 0;
+const test_1 = require("@playwright/test");
+/**
+ * Content type used to identify CTRF runtime messages in attachments.
+ * The reporter will look for attachments with this content type.
+ */
+exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE = 'application/vnd.ctrf.message+json';
+/**
+ * Silent fallback when no test is active - prevents errors in setup/teardown code.
+ */
+const nullTransport = {
+    send: () => __awaiter(void 0, void 0, void 0, function* () {
+        /* intentionally empty */
+    }),
+};
+/**
+ * Attaches metadata payloads to the current Playwright test as hidden attachments.
+ * The reporter extracts these by content type during report generation.
+ */
+function createPlaywrightTransport() {
+    let sequence = 0;
+    return {
+        send(payload) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tag = `__ctrf_${++sequence}_${Date.now()}`;
+                const data = JSON.stringify(payload);
+                yield test_1.test.info().attach(tag, {
+                    contentType: exports.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE,
+                    body: Buffer.from(data),
+                });
+            });
+        },
+    };
+}
+const activeTransport = createPlaywrightTransport();
+/**
+ * Resolves the active transport, or a null transport if outside a test.
+ */
+const resolveTransport = () => {
+    try {
+        if (test_1.test.info())
+            return activeTransport;
+    }
+    catch (_a) {
+        // Outside test context
+    }
+    return nullTransport;
+};
+/* ═══════════════════════════════════════════════════════════════════════════
+ * Public API
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Attach custom metadata to the current test.
+ *
+ * @param data - Key-value pairs to include in the CTRF report's `extra` field
+ * @returns Promise (can be ignored; completes when attachment is written)
+ *
+ * @remarks
+ * - Multiple calls accumulate; later keys overwrite earlier ones (shallow merge)
+ * - Safe to call from helper functions - binds to the active test automatically
+ * - No-op outside test context (e.g., in global setup)
+ *
+ * @example
+ * ctrf.extra({ owner: 'platform-team' })
+ * ctrf.extra({ executionId: uuid(), retryable: true })
+ */
+function extra(data) {
+    return resolveTransport().send({ type: 'metadata', data });
+}
+exports.extra = extra;
+/** CTRF runtime API namespace */
+exports.ctrf = { extra };

package/dist/generate-report.d.ts

@@ -18,6 +18,7 @@ interface ReporterConfigOptions {
     repositoryName?: string | undefined;
     repositoryUrl?: string | undefined;
     branchName?: string | undefined;
+    commit?: string | undefined;
     testEnvironment?: string | undefined;
 }
 declare class GenerateCtrfReport implements Reporter {
@@ -42,6 +43,24 @@ declare class GenerateCtrfReport implements Reporter {
     setEnvironmentDetails(reporterConfigOptions: ReporterConfigOptions): void;
     hasEnvironmentDetails(environment: CtrfEnvironment): boolean;
     extractMetadata(testResult: TestResult): any;
+    /**
+     * Extract and merge runtime data from CTRF message attachments.
+     *
+     * Runtime messages are internal transport artifacts used to send data from
+     * test code to the reporter via test.info().attach(). They are identified
+     * by the CTRF_RUNTIME_MESSAGE_CONTENT_TYPE content type.
+     *
+     * ## Merge Semantics (shallow merge)
+     *
+     * Messages are processed in attachment order and merged using Object.assign:
+     * - Later messages overwrite earlier keys with the same name
+     * - Non-overlapping keys are preserved
+     * - Arrays and objects are replaced wholesale, not deep-merged
+     *
+     * @param testResult - The test result containing attachments
+     * @returns Merged runtime data or null if no CTRF messages found
+     */
+    extractRuntimeData(testResult: TestResult): Record<string, unknown> | null;
     updateStart(startTime: Date): number;
     calculateStopTime(startTime: Date, duration: number): number;
     buildSuitePath(test: TestCase): string;
@@ -50,6 +69,16 @@ declare class GenerateCtrfReport implements Reporter {
     countSuites(suite: Suite): number;
     writeReportToFile(data: CtrfReport): void;
     processStep(test: CtrfTest, step: TestStep): void;
+    /**
+     * Filter attachments to include in CTRF output.
+     *
+     * Excludes:
+     * - Attachments without a file path (body-only attachments)
+     * - CTRF runtime message attachments (internal transport artifacts)
+     *
+     * Runtime messages exist only to transmit data from test → reporter and
+     * are not user-facing attachments.
+     */
     filterValidAttachments(attachments: TestResult['attachments']): CtrfAttachment[];
 }
 export default GenerateCtrfReport;

package/dist/generate-report.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const crypto_1 = __importDefault(require("crypto"));
+const adapter_1 = require("./adapter");
 class GenerateCtrfReport {
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
         this.reporterName = 'playwright-ctrf-json-reporter';
         this.defaultOutputFile = 'ctrf-report.json';
         this.defaultOutputDir = 'ctrf';
@@ -30,7 +31,8 @@ class GenerateCtrfReport {
             repositoryName: (_q = config === null || config === void 0 ? void 0 : config.repositoryName) !== null && _q !== void 0 ? _q : undefined,
             repositoryUrl: (_r = config === null || config === void 0 ? void 0 : config.repositoryUrl) !== null && _r !== void 0 ? _r : undefined,
             branchName: (_s = config === null || config === void 0 ? void 0 : config.branchName) !== null && _s !== void 0 ? _s : undefined,
-            testEnvironment: (_t = config === null || config === void 0 ? void 0 : config.testEnvironment) !== null && _t !== void 0 ? _t : undefined,
+            commit: (_t = config === null || config === void 0 ? void 0 : config.commit) !== null && _t !== void 0 ? _t : undefined,
+            testEnvironment: (_u = config === null || config === void 0 ? void 0 : config.testEnvironment) !== null && _u !== void 0 ? _u : undefined,
         };
         this.ctrfReport = {
             reportFormat: 'CTRF',
@@ -148,9 +150,15 @@ class GenerateCtrfReport {
             test.attachments = this.filterValidAttachments(testResult.attachments);
             test.stdout = testResult.stdout.map((item) => Buffer.isBuffer(item) ? item.toString() : String(item));
             test.stderr = testResult.stderr.map((item) => Buffer.isBuffer(item) ? item.toString() : String(item));
+            // Initialize extra with annotations if configured
             if (this.reporterConfigOptions.annotations !== undefined) {
                 test.extra = { annotations: testCase.annotations };
             }
+            // Merge runtime data from ctrf.extra() calls
+            const runtimeData = this.extractRuntimeData(testResult);
+            if (runtimeData !== null) {
+                test.extra = Object.assign(Object.assign({}, test.extra), runtimeData);
+            }
             if (testCase.results.length > 1) {
                 const retryResults = testCase.results.slice(0, -1);
                 test.retryAttempts = [];
@@ -228,6 +236,9 @@ class GenerateCtrfReport {
         if (reporterConfigOptions.branchName !== undefined) {
             this.ctrfEnvironment.branchName = reporterConfigOptions.branchName;
         }
+        if (reporterConfigOptions.commit !== undefined) {
+            this.ctrfEnvironment.commit = reporterConfigOptions.commit;
+        }
         if (reporterConfigOptions.testEnvironment !== undefined) {
             this.ctrfEnvironment.testEnvironment =
                 reporterConfigOptions.testEnvironment;
@@ -255,6 +266,49 @@ class GenerateCtrfReport {
         }
         return null;
     }
+    /**
+     * Extract and merge runtime data from CTRF message attachments.
+     *
+     * Runtime messages are internal transport artifacts used to send data from
+     * test code to the reporter via test.info().attach(). They are identified
+     * by the CTRF_RUNTIME_MESSAGE_CONTENT_TYPE content type.
+     *
+     * ## Merge Semantics (shallow merge)
+     *
+     * Messages are processed in attachment order and merged using Object.assign:
+     * - Later messages overwrite earlier keys with the same name
+     * - Non-overlapping keys are preserved
+     * - Arrays and objects are replaced wholesale, not deep-merged
+     *
+     * @param testResult - The test result containing attachments
+     * @returns Merged runtime data or null if no CTRF messages found
+     */
+    extractRuntimeData(testResult) {
+        const runtimeData = {};
+        let hasData = false;
+        for (const attachment of testResult.attachments) {
+            if (attachment.contentType !== adapter_1.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE) {
+                continue;
+            }
+            if (attachment.body === undefined) {
+                continue;
+            }
+            try {
+                const message = JSON.parse(attachment.body.toString('utf-8'));
+                if (message.type === 'metadata' && message.data !== null) {
+                    Object.assign(runtimeData, message.data);
+                    hasData = true;
+                }
+            }
+            catch (e) {
+                // Silently ignore malformed messages
+                if (e instanceof Error) {
+                    console.error(`Error parsing CTRF runtime message: ${e.message}`);
+                }
+            }
+        }
+        return hasData ? runtimeData : null;
+    }
     updateStart(startTime) {
         const date = new Date(startTime);
         const unixEpochTime = Math.floor(date.getTime() / 1000);
@@ -340,9 +394,29 @@ class GenerateCtrfReport {
             });
         }
     }
+    /**
+     * Filter attachments to include in CTRF output.
+     *
+     * Excludes:
+     * - Attachments without a file path (body-only attachments)
+     * - CTRF runtime message attachments (internal transport artifacts)
+     *
+     * Runtime messages exist only to transmit data from test → reporter and
+     * are not user-facing attachments.
+     */
     filterValidAttachments(attachments) {
         return attachments
-            .filter((attachment) => attachment.path !== undefined)
+            .filter((attachment) => {
+            // Exclude attachments without a path
+            if (attachment.path === undefined) {
+                return false;
+            }
+            // Exclude CTRF runtime messages (internal transport)
+            if (attachment.contentType === adapter_1.CTRF_RUNTIME_MESSAGE_CONTENT_TYPE) {
+                return false;
+            }
+            return true;
+        })
             .map((attachment) => {
             var _a;
             return ({

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { default } from './generate-report';
+export { ctrf, extra } from './adapter';

package/dist/index.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
+exports.extra = exports.ctrf = exports.default = void 0;
 var generate_report_1 = require("./generate-report");
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(generate_report_1).default; } });
+var adapter_1 = require("./adapter");
+Object.defineProperty(exports, "ctrf", { enumerable: true, get: function () { return adapter_1.ctrf; } });
+Object.defineProperty(exports, "extra", { enumerable: true, get: function () { return adapter_1.extra; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright-ctrf-json-reporter",
-  "version": "0.0.26",
+  "version": "0.0.28-next-0",
   "description": "A Playwright JSON test reporter to create test results reports",
   "main": "dist/index.js",
   "scripts": {
@@ -17,8 +17,7 @@
     "url": "git+https://github.com/ctrf-io/playwright-ctrf-json-reporter.git"
   },
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "homepage": "https://ctrf.io",
   "files": [