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

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

@@ -27,6 +27,7 @@ declare class TmsReporter implements Reporter {
     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>;
@@ -34,6 +35,11 @@ declare class TmsReporter implements Reporter {
     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,6 +19,7 @@ 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");
@@ -66,6 +67,17 @@ class TmsReporter {
     _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;
@@ -148,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;
@@ -170,49 +185,6 @@ class TmsReporter {
                 }
                 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 {
@@ -228,35 +200,84 @@ class TmsReporter {
                 }
             }
         }
+        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) {
         testit_js_commons_2.logger.debug("[playwright] loadTest", { title: test.title, status: result.status });
-        const autotestData = await this.getAutotestData(test, result);
-        const origin = await this.strategy.client.autoTests.getAutotestByExternalId(autotestData.externalId);
-        if (!origin) {
+        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.1.0",
+  "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.1.0"
+    "testit-js-commons": "4.1.1-TMS-5.7"
   },
   "files": [
     "dist"