testit-adapter-playwright 4.0.5 → 4.1.1-TMS-5.7

package/README.md

@@ -12,6 +12,12 @@ npm install testit-adapter-playwright
 
 ### Configuration
 
+
+#### Log level
+
+The adapter includes a custom logger; the default level is `warn`. Set another level at runtime with the `LOG_LEVEL` environment variable: `error`, `warn`, `info`, or `debug`.
+
+
 | Description                                                                                                                                                                                                                                                                                                                                                                            | File property                     | Environment variable                       |
 |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------|--------------------------------------------|
 | Location of the TMS instance                                                                                                                                                                                                                                                                                                                                                           | url                               | TMS_URL                                    |
@@ -24,6 +30,7 @@ npm install testit-adapter-playwright
 | It enables/disables certificate validation (**It's optional**). Default value - true                                                                                                                                                                                                                                                                                                   | certValidation                    | TMS_CERT_VALIDATION                        |
 | Mode of automatic creation test cases (**It's optional**). Default value - false. The adapter supports following modes:<br/>true - in this mode, the adapter will create a test case linked to the created autotest (not to the updated autotest)<br/>false - in this mode, the adapter will not create a test case                                                                    | automaticCreationTestCases        | TMS_AUTOMATIC_CREATION_TEST_CASES          |
 | Mode of automatic updation links to test cases (**It's optional**). Default value - false. The adapter supports following modes:<br/>true - in this mode, the adapter will update links to test cases<br/>false - in this mode, the adapter will not update link to test cases                                                                                                         | automaticUpdationLinksToTestCases | TMS_AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES |
+| Logger level, default value is `warn`, available values: [`error`, `warn`, `info`, `debug`] | | LOG_LEVEL |
 
 Add Adapter to Playwright file configuration:
 

package/dist/labels.d.ts

@@ -46,6 +46,9 @@ export declare enum Extensions {
 }
 type Parameters = Record<string, string>;
 export declare class testit {
+    private static isMetadataAttachment;
+    private static readAttachmentBuffer;
+    private static mergeMetadataAttachments;
     private static addMetadataAttachment;
     static addAttachment(name: string, content: Buffer | string, options: ContentType | string | Pick<AttachmentOptions, "contentType">): Promise<void>;
     private static mapParams;

package/dist/labels.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.testit = exports.Extensions = exports.ContentType = void 0;
 const crypto_1 = require("crypto");
 const test_1 = __importDefault(require("@playwright/test"));
+const testit_js_commons_1 = require("testit-js-commons");
+const metadata_store_1 = require("./metadata-store");
 const utils_1 = require("./utils");
 var ContentType;
 (function (ContentType) {
@@ -34,10 +36,45 @@ var Extensions;
     Extensions["MD"] = ".md";
 })(Extensions || (exports.Extensions = Extensions = {}));
 class testit {
+    static isMetadataAttachment(attachment) {
+        return (attachment.contentType === "application/vnd.tms.metadata+json" ||
+            attachment.name === "tms-metadata.json");
+    }
+    static readAttachmentBuffer(attachment) {
+        if (attachment.body) {
+            return attachment.body;
+        }
+        if (!attachment.path) {
+            return undefined;
+        }
+        try {
+            return testit_js_commons_1.Utils.readBufferSync(attachment.path);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static mergeMetadataAttachments() {
+        let merged = {};
+        for (const attachment of test_1.default.info().attachments) {
+            if (!this.isMetadataAttachment(attachment)) {
+                continue;
+            }
+            const body = this.readAttachmentBuffer(attachment);
+            if (!body) {
+                continue;
+            }
+            merged = { ...merged, ...JSON.parse(body.toString()) };
+        }
+        return merged;
+    }
     static async addMetadataAttachment(metadata) {
+        const info = test_1.default.info();
+        (0, metadata_store_1.patchTestMetadataForRun)({ testId: info.testId, file: info.file, titlePath: info.titlePath, title: info.title }, metadata);
+        const merged = { ...this.mergeMetadataAttachments(), ...metadata };
         await test_1.default.info().attach("tms-metadata.json", {
             contentType: "application/vnd.tms.metadata+json",
-            body: Buffer.from(JSON.stringify(metadata), "utf8"),
+            body: Buffer.from(JSON.stringify(merged), "utf8"),
         });
     }
     static async addAttachment(name, content, options) {

package/dist/metadata-store.d.ts

@@ -0,0 +1,24 @@
+import type { MetadataMessage } from "./labels";
+export declare function metadataKey(file: string, titlePath: string[]): string;
+export type MetadataRunContext = {
+    testId: string;
+    file: string;
+    titlePath: string[];
+    title: string;
+};
+export declare function metadataKeys(ctx: MetadataRunContext): string[];
+/** In-process metadata from testit.*(); attachments alone are unreliable in the reporter. */
+export declare function patchTestMetadataForRun(ctx: MetadataRunContext, patch: MetadataMessage): void;
+export declare function resolveTestMetadata(ctx: {
+    testId: string;
+    file: string;
+    titlePath: string[];
+    title: string;
+}): MetadataMessage | undefined;
+export declare function releaseTestMetadata(ctx: {
+    testId: string;
+    file: string;
+    titlePath: string[];
+    title: string;
+}): void;
+export declare function applyMetadataTo(target: MetadataMessage, source: MetadataMessage): void;

package/dist/metadata-store.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadataKey = metadataKey;
+exports.metadataKeys = metadataKeys;
+exports.patchTestMetadataForRun = patchTestMetadataForRun;
+exports.resolveTestMetadata = resolveTestMetadata;
+exports.releaseTestMetadata = releaseTestMetadata;
+exports.applyMetadataTo = applyMetadataTo;
+const path_1 = __importDefault(require("path"));
+const testit_js_commons_1 = require("testit-js-commons");
+const STORE_KEY = Symbol.for("testit.playwright.metadata");
+function metadataMap() {
+    const g = globalThis;
+    if (!g[STORE_KEY]) {
+        g[STORE_KEY] = new Map();
+    }
+    return g[STORE_KEY];
+}
+function metadataKey(file, titlePath) {
+    return `${path_1.default.resolve(file)}\0${titlePath.join("\0")}`;
+}
+function metadataKeys(ctx) {
+    const fullTitle = ctx.titlePath.join(" › ");
+    return [
+        ctx.testId,
+        metadataKey(ctx.file, ctx.titlePath),
+        metadataKey(ctx.file, [ctx.title]),
+        `hash:${testit_js_commons_1.Utils.getHash(ctx.title)}`,
+        `hash:${testit_js_commons_1.Utils.getHash(fullTitle)}`,
+    ];
+}
+/** In-process metadata from testit.*(); attachments alone are unreliable in the reporter. */
+function patchTestMetadataForRun(ctx, patch) {
+    for (const key of metadataKeys(ctx)) {
+        const map = metadataMap();
+        map.set(key, { ...(map.get(key) ?? {}), ...patch });
+    }
+}
+function peekTestMetadata(key) {
+    return metadataMap().get(key);
+}
+function resolveTestMetadata(ctx) {
+    let merged = {};
+    let found = false;
+    for (const key of metadataKeys(ctx)) {
+        const chunk = peekTestMetadata(key);
+        if (!chunk) {
+            continue;
+        }
+        merged = { ...merged, ...chunk };
+        found = true;
+    }
+    return found ? merged : undefined;
+}
+function releaseTestMetadata(ctx) {
+    const map = metadataMap();
+    for (const key of metadataKeys(ctx)) {
+        map.delete(key);
+    }
+}
+function applyMetadataTo(target, source) {
+    if (source.externalId) {
+        target.externalId = source.externalId;
+    }
+    if (source.displayName) {
+        target.displayName = source.displayName;
+    }
+    if (source.title) {
+        target.title = source.title;
+    }
+    if (source.description) {
+        target.description = source.description;
+    }
+    if (source.labels) {
+        target.labels = source.labels;
+    }
+    if (source.tags) {
+        target.tags = source.tags;
+    }
+    if (source.links) {
+        target.links = source.links;
+    }
+    if (source.namespace) {
+        target.namespace = source.namespace;
+    }
+    if (source.classname) {
+        target.classname = source.classname;
+    }
+    if (source.addLinks) {
+        target.addLinks = source.addLinks;
+    }
+    if (source.addMessage) {
+        target.addMessage = source.addMessage;
+    }
+    if (source.params) {
+        target.params = source.params;
+    }
+    if (source.workItemIds) {
+        target.workItemIds = source.workItemIds;
+    }
+    if (source.externalKey) {
+        target.externalKey = source.externalKey;
+    }
+}

package/dist/reporter.d.ts

@@ -20,17 +20,26 @@ declare class TmsReporter implements Reporter {
     private attachmentsMap;
     private loadTestPromises;
     private setupPromise;
+    private readonly adapterConfig;
+    private bufferedResults;
     constructor(options: ReporterOptions);
     onBegin(config: FullConfig, suite: Suite): void;
     onTestBegin(test: TestCase): void;
     onTestEnd(test: TestCase, result: TestResult): void;
     private _processAttachmentsWithExtensions;
+    private metadataContext;
     onStepBegin(test: TestCase, _result: TestResult, step: TestStep): void;
     onEnd(): Promise<void>;
     addSkippedResults(): Promise<void>;
+    private runLoadTest;
     printsToStdio(): boolean;
     private getDictionariesByTest;
     private getAutotestData;
+    private isMetadataAttachment;
+    /** Playwright copies inline attach to disk — reporter often gets path only, not body. */
+    private readAttachmentBuffer;
+    /** Each testit.*() call may add a separate tms-metadata.json; merge all of them. */
+    private applyMetadataAttachments;
     private loadTest;
 }
 export default TmsReporter;

package/dist/reporter.js

@@ -19,8 +19,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const testit_js_commons_1 = require("testit-js-commons");
 const converter_1 = require("./converter");
+const metadata_store_1 = require("./metadata-store");
 const utils_1 = require("./utils");
 const path_1 = __importDefault(require("path"));
+const testit_js_commons_2 = require("testit-js-commons");
 class TmsReporter {
     constructor(options) {
         this.testCache = new Array();
@@ -29,10 +31,13 @@ class TmsReporter {
         this.attachmentsMap = new Map();
         this.loadTestPromises = new Array();
         this.setupPromise = Promise.resolve();
+        this.bufferedResults = [];
         this.options = { suiteTitle: true, detail: true, ...options };
         const config = new testit_js_commons_1.ConfigComposer().compose(options.tmsOptions);
+        this.adapterConfig = config;
         this.strategy = testit_js_commons_1.StrategyFactory.create(config);
         this.additions = new testit_js_commons_1.Additions(config);
+        testit_js_commons_2.logger.debug("[playwright] reporter init", { importRealtime: Boolean(config.importRealtime) });
     }
     onBegin(config, suite) {
         this.config = config;
@@ -43,21 +48,36 @@ class TmsReporter {
         this.testCache.push(test);
     }
     onTestEnd(test, result) {
-        this.loadTestPromises.push(this.setupPromise.then(() => this.loadTest(test, {
+        const currentResult = {
             status: result.status,
             attachments: this._processAttachmentsWithExtensions(result),
             duration: result.duration,
             errors: result.errors,
             error: result.error,
             steps: result.steps,
-        })).catch((err) => {
-            console.log("Error processing test result. \n", err?.body ?? err?.error ?? err);
-        }));
+        };
+        if (this.adapterConfig.importRealtime) {
+            testit_js_commons_2.logger.debug("[playwright] onTestEnd realtime", { title: test.title, status: result.status });
+            this.loadTestPromises.push(this.runLoadTest(test, currentResult));
+            return;
+        }
+        this.bufferedResults.push({ test, result: currentResult });
     }
     // fix issues with trace and video files on playwright
     _processAttachmentsWithExtensions(result) {
         return result.attachments.map(utils_1.processAttachmentExtensions);
     }
+    metadataContext(test) {
+        const titlePath = typeof test.titlePath === "function"
+            ? test.titlePath()
+            : [test.title];
+        return {
+            testId: test.id,
+            file: test.location.file,
+            titlePath,
+            title: test.title,
+        };
+    }
     onStepBegin(test, _result, step) {
         if (!this.testCache.includes(test)) {
             return;
@@ -80,17 +100,24 @@ class TmsReporter {
     async onEnd() {
         try {
             await this.setupPromise.catch((err) => {
-                console.error("TMS Playwright setup failed:", err?.body ?? err?.error ?? err);
+                testit_js_commons_2.logger.error("TMS Playwright setup failed:", err?.body ?? err?.error ?? err);
             });
+            if (!this.adapterConfig.importRealtime) {
+                testit_js_commons_2.logger.debug("[playwright] onEnd batch flush", { count: this.bufferedResults.length });
+                await Promise.allSettled(this.bufferedResults.map(({ test, result }) => this.runLoadTest(test, result)));
+            }
+            else {
+                testit_js_commons_2.logger.debug("[playwright] onEnd await realtime", { pending: this.loadTestPromises.length });
+            }
             await Promise.allSettled(this.loadTestPromises);
             await this.addSkippedResults();
         }
         catch (err) {
-            console.error("TMS Playwright onEnd failed:", err?.body ?? err?.error ?? err);
+            testit_js_commons_2.logger.error("TMS Playwright onEnd failed:", err?.body ?? err?.error ?? err);
         }
         finally {
             await this.strategy.teardown().catch((err) => {
-                console.error("TMS Playwright teardown failed:", err?.body ?? err?.error ?? err);
+                testit_js_commons_2.logger.error("TMS Playwright teardown failed:", err?.body ?? err?.error ?? err);
             });
         }
     }
@@ -105,9 +132,16 @@ class TmsReporter {
             errors: [],
             steps: [],
         }).catch((err) => {
-            console.error("TMS Playwright loadTest (skipped) failed:", testCase?.title, err?.body ?? err?.error ?? err);
+            testit_js_commons_2.logger.error("TMS Playwright loadTest (skipped) failed:", testCase?.title, err?.body ?? err?.error ?? err);
         })));
     }
+    runLoadTest(test, result) {
+        return this.setupPromise
+            .then(() => this.loadTest(test, result))
+            .catch((err) => {
+            testit_js_commons_2.logger.log("Error processing test result. \n", err?.body ?? err?.error ?? err);
+        });
+    }
     printsToStdio() {
         return false;
     }
@@ -126,6 +160,9 @@ class TmsReporter {
             externalKey: test.title,
         };
         for (const attachment of result.attachments) {
+            if (this.isMetadataAttachment(attachment)) {
+                continue;
+            }
             if (!attachment.body) {
                 if (attachment.path && attachment.name !== "screenshot") {
                     let content;
@@ -143,54 +180,11 @@ class TmsReporter {
                         autotestData.addAttachments?.push(...ids);
                     }
                     catch (err) {
-                        console.log("Error uploading file attachment. \n", err?.body ?? err?.error ?? err);
+                        testit_js_commons_2.logger.log("Error uploading file attachment. \n", err?.body ?? err?.error ?? err);
                     }
                 }
                 continue;
             }
-            if (attachment.contentType === "application/vnd.tms.metadata+json") {
-                const metadata = JSON.parse(attachment.body.toString());
-                if (metadata.externalId) {
-                    autotestData.externalId = metadata.externalId;
-                }
-                if (metadata.displayName) {
-                    autotestData.displayName = metadata.displayName;
-                }
-                if (metadata.title) {
-                    autotestData.title = metadata.title;
-                }
-                if (metadata.description) {
-                    autotestData.description = metadata.description;
-                }
-                if (metadata.labels) {
-                    autotestData.labels = metadata.labels;
-                }
-                if (metadata.tags) {
-                    autotestData.tags = metadata.tags;
-                }
-                if (metadata.links) {
-                    autotestData.links = metadata.links;
-                }
-                if (metadata.namespace) {
-                    autotestData.namespace = metadata.namespace;
-                }
-                if (metadata.classname) {
-                    autotestData.classname = metadata.classname;
-                }
-                if (metadata.addLinks) {
-                    autotestData.addLinks = metadata.addLinks;
-                }
-                if (metadata.addMessage) {
-                    autotestData.addMessage = metadata.addMessage;
-                }
-                if (metadata.params) {
-                    autotestData.params = metadata.params;
-                }
-                if (metadata.workItemIds) {
-                    autotestData.workItemIds = metadata.workItemIds;
-                }
-                continue;
-            }
             if (attachment.name.match(utils_1.stepAttachRegexp)) {
                 const step = this.attachmentStepsCache.find((step) => step.title === attachment.name);
                 try {
@@ -202,38 +196,88 @@ class TmsReporter {
                     autotestData.addAttachments?.push(...ids);
                 }
                 catch (err) {
-                    console.log("Error uploading text attachment. \n", err?.body ?? err?.error ?? err);
+                    testit_js_commons_2.logger.log("Error uploading text attachment. \n", err?.body ?? err?.error ?? err);
                 }
             }
         }
+        this.applyMetadataAttachments(autotestData, result.attachments);
+        const stored = (0, metadata_store_1.resolveTestMetadata)(this.metadataContext(test));
+        if (stored) {
+            (0, metadata_store_1.applyMetadataTo)(autotestData, stored);
+            testit_js_commons_2.logger.debug("[playwright] metadata from store", {
+                title: test.title,
+                namespace: autotestData.namespace,
+                classname: autotestData.classname,
+            });
+        }
         return autotestData;
     }
+    isMetadataAttachment(attachment) {
+        return (attachment.contentType === "application/vnd.tms.metadata+json" ||
+            attachment.name === "tms-metadata.json");
+    }
+    /** Playwright copies inline attach to disk — reporter often gets path only, not body. */
+    readAttachmentBuffer(attachment) {
+        if (attachment.body) {
+            return attachment.body;
+        }
+        if (!attachment.path) {
+            return undefined;
+        }
+        try {
+            return testit_js_commons_1.Utils.readBufferSync(attachment.path);
+        }
+        catch (err) {
+            if (err?.code === "ENOENT") {
+                return undefined;
+            }
+            throw err;
+        }
+    }
+    /** Each testit.*() call may add a separate tms-metadata.json; merge all of them. */
+    applyMetadataAttachments(autotestData, attachments) {
+        let merged = {};
+        for (const attachment of attachments) {
+            if (!this.isMetadataAttachment(attachment)) {
+                continue;
+            }
+            const body = this.readAttachmentBuffer(attachment);
+            if (!body) {
+                continue;
+            }
+            merged = { ...merged, ...JSON.parse(body.toString()) };
+        }
+        (0, metadata_store_1.applyMetadataTo)(autotestData, merged);
+    }
     async loadTest(test, result) {
-        const autotestData = await this.getAutotestData(test, result);
-        const origin = await this.strategy.client.autoTests.getAutotestByExternalId(autotestData.externalId);
-        if (!origin) {
+        testit_js_commons_2.logger.debug("[playwright] loadTest", { title: test.title, status: result.status });
+        try {
+            const autotestData = await this.getAutotestData(test, result);
             const dictionaries = this.getDictionariesByTest(test);
             const pathNamespace = dictionaries.slice(0, -1).join(path_1.default.sep);
             const pathClassname = dictionaries[dictionaries.length - 1];
-            // Prefer testit.namespace / testit.classname from attachments; file path is the default only when missing.
+            // Prefer testit.namespace / testit.classname from metadata; file path only when missing.
             if (pathNamespace.length > 0 && autotestData.namespace == null) {
                 autotestData.namespace = pathNamespace;
             }
             if (pathClassname?.length && autotestData.classname == null) {
                 autotestData.classname = pathClassname;
             }
+            const autotest = converter_1.Converter.convertTestCaseToAutotestPost(autotestData);
+            const rawSteps = result.steps?.length
+                ? result.steps
+                : [...this.stepsMap.keys()].filter((step) => this.stepsMap.get(step) === test);
+            const stepResults = converter_1.Converter.convertTestStepsToSteps(rawSteps, this.attachmentsMap);
+            result.status = (0, utils_1.getTestStatus)(test);
+            autotest.steps = converter_1.Converter.convertTestStepsToShortSteps(rawSteps);
+            await this.strategy.loadAutotest(autotest, converter_1.Converter.convertStatus(result.status, test.expectedStatus));
+            const autotestResult = converter_1.Converter.convertAutotestPostToAutotestResult(autotestData, test, result);
+            autotestResult.stepResults = stepResults;
+            await this.strategy.loadTestRun([autotestResult]);
+        }
+        finally {
+            (0, metadata_store_1.releaseTestMetadata)(this.metadataContext(test));
         }
-        const autotest = converter_1.Converter.convertTestCaseToAutotestPost(autotestData);
-        const rawSteps = result.steps?.length
-            ? result.steps
-            : [...this.stepsMap.keys()].filter((step) => this.stepsMap.get(step) === test);
-        const stepResults = converter_1.Converter.convertTestStepsToSteps(rawSteps, this.attachmentsMap);
-        result.status = (0, utils_1.getTestStatus)(test);
-        autotest.steps = converter_1.Converter.convertTestStepsToShortSteps(rawSteps);
-        await this.strategy.loadAutotest(autotest, converter_1.Converter.convertStatus(result.status, test.expectedStatus));
-        const autotestResult = converter_1.Converter.convertAutotestPostToAutotestResult(autotestData, test, result);
-        autotestResult.stepResults = stepResults;
-        await this.strategy.loadTestRun([autotestResult]);
     }
 }
 exports.default = TmsReporter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testit-adapter-playwright",
-  "version": "4.0.5",
+  "version": "4.1.1-TMS-5.7",
   "description": "Playwright adapter for Test IT",
   "license": "Apache-2.0",
   "author": {
@@ -40,7 +40,7 @@
     "prettier": "^3.0.1"
   },
   "dependencies": {
-    "testit-js-commons": "4.0.5"
+    "testit-js-commons": "4.1.1-TMS-5.7"
   },
   "files": [
     "dist"