testit-adapter-jest 3.7.9 → 4.0.0

package/dist/globalSetup.js

@@ -1,11 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const testit_js_commons_1 = require("testit-js-commons");
+const globalUnhandledRejectionLogger = (reason) => {
+    const normalized = reason?.body ?? reason?.error ?? reason;
+    console.error("[jest-globalSetup] unhandledRejection:", normalized);
+};
 exports.default = async (globalConfig, projectConfig) => {
-    const config = new testit_js_commons_1.ConfigComposer().compose(projectConfig.testEnvironmentOptions);
-    const strategy = testit_js_commons_1.StrategyFactory.create(config);
-    await strategy.setup();
-    const testRunId = await strategy.testRunId;
-    projectConfig.testEnvironmentOptions["testRunId"] = testRunId;
-    projectConfig.testEnvironmentOptions["adapterMode"] = 1;
+    process.on("unhandledRejection", globalUnhandledRejectionLogger);
+    try {
+        const config = new testit_js_commons_1.ConfigComposer().compose(projectConfig.testEnvironmentOptions);
+        const strategy = testit_js_commons_1.StrategyFactory.create(config);
+        // Do not run setup in globalSetup: Jest workers run in separate processes and would then
+        // send results from non-master contexts. Let each worker environment run setup locally.
+        const testRunId = await strategy.testRunId;
+        projectConfig.testEnvironmentOptions["testRunId"] = testRunId;
+        projectConfig.testEnvironmentOptions["adapterMode"] = 1;
+    }
+    catch (err) {
+        console.error("Failed globalSetup for testit-adapter-jest:", err?.body ?? err?.error ?? err);
+    }
 };

package/dist/globalTeardown.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = async (globalConfig, projectConfig) => {
     try {
-        await globalThis.strategy.teardown();
+        if (globalThis.strategy) {
+            await globalThis.strategy.teardown();
+        }
     }
     catch (err) {
         console.error('Failed to complete test run');

package/dist/testitEnvironment.d.ts

@@ -15,12 +15,16 @@ export default class TestItEnvironment extends NodeEnvironment {
     private attachmentsQueue;
     private readonly strategy;
     private readonly additions;
+    private readonly usesGlobalStrategy;
+    private readonly unhandledRejectionHandler;
+    private finalized;
     constructor(jestConfig: JestEnvironmentConfig, jestContext: EnvironmentContext);
     setup(): Promise<void>;
     teardown(): Promise<void>;
     getVmContext(): import("vm").Context | null;
     exportConditions(): string[];
     handleTestEvent(event: Event): Promise<void>;
+    private formatError;
     startHookCapture(hook: Extract<Event, {
         name: "hook_start";
     }>["hook"]): void;

package/dist/testitEnvironment.js

@@ -34,13 +34,55 @@ class TestItEnvironment extends jest_environment_node_1.default {
         this.autotestResults = [];
         this.autotests = [];
         this.attachmentsQueue = [];
+        this.finalized = false;
         const config = new testit_js_commons_1.ConfigComposer().compose(jestConfig.projectConfig.testEnvironmentOptions);
         this.additions = new testit_js_commons_1.Additions(config);
-        this.strategy = testit_js_commons_1.StrategyFactory.create(config);
+        this.usesGlobalStrategy = Boolean(globalThis.strategy);
+        this.strategy = globalThis.strategy ?? testit_js_commons_1.StrategyFactory.create(config);
+        this.unhandledRejectionHandler = (reason) => {
+            console.error("Unhandled promise rejection in Jest environment:", this.formatError(reason));
+        };
         this.testPath = (0, utils_1.excludePath)(jestContext.testPath, jestConfig.globalConfig.rootDir);
     }
     async setup() {
+        // Register as early as possible for this worker process.
+        process.on("unhandledRejection", this.unhandledRejectionHandler);
         await super.setup();
+        const testRunId = await this.strategy.testRunId;
+        const syncRunner = this.strategy.syncStorageRunner;
+        console.log("[jest-env] setup start", {
+            pid: process.pid,
+            testRunId,
+            usesGlobalStrategy: this.usesGlobalStrategy,
+            syncRunnerActive: Boolean(syncRunner?.isActive?.()),
+            syncRunnerMaster: Boolean(syncRunner?.isMasterWorker?.()),
+        });
+        // Jest workers run in separate processes and do not share globalThis.strategy from globalSetup.
+        // For those workers, run setup locally to register in sync storage (master will publish in-progress).
+        if (!this.usesGlobalStrategy) {
+            try {
+                await this.strategy.setup();
+                const localSyncRunner = this.strategy.syncStorageRunner;
+                console.log("[jest-env] local setup done", {
+                    pid: process.pid,
+                    testRunId,
+                    syncRunnerActive: Boolean(localSyncRunner?.isActive?.()),
+                    syncRunnerMaster: Boolean(localSyncRunner?.isMasterWorker?.()),
+                });
+            }
+            catch (err) {
+                console.error("Failed local strategy.setup() in Jest environment:", this.formatError(err));
+            }
+        }
+        else {
+            const sharedSyncRunner = this.strategy.syncStorageRunner;
+            console.log("[jest-env] shared strategy mode", {
+                pid: process.pid,
+                testRunId,
+                syncRunnerActive: Boolean(sharedSyncRunner?.isActive?.()),
+                syncRunnerMaster: Boolean(sharedSyncRunner?.isMasterWorker?.()),
+            });
+        }
         this.global.testit = {
             externalId: this.setExternalId.bind(this),
             displayName: this.setDisplayName.bind(this),
@@ -60,6 +102,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
         };
     }
     async teardown() {
+        process.off("unhandledRejection", this.unhandledRejectionHandler);
         await super.teardown();
     }
     getVmContext() {
@@ -69,38 +112,63 @@ class TestItEnvironment extends jest_environment_node_1.default {
         return super.exportConditions();
     }
     async handleTestEvent(event) {
-        switch (event.name) {
-            case "hook_start": {
-                this.startHookCapture(event.hook);
-                break;
-            }
-            case "hook_success":
-            case "hook_failure": {
-                this.finishHookCapture(event.hook);
-                break;
-            }
-            case "test_fn_start": {
-                this.startTestCapture(event.test);
-                break;
-            }
-            case "test_fn_success":
-            case "test_fn_failure": {
-                this.finishTestCapture(event.test);
-                break;
-            }
-            case "test_done": {
-                await this.saveResult(event.test);
-                break;
-            }
-            case "test_skip": {
-                this.resetTest();
-                break;
-            }
-            case "run_finish": {
-                await this.loadResults();
-                break;
+        try {
+            switch (event.name) {
+                case "hook_start": {
+                    this.startHookCapture(event.hook);
+                    break;
+                }
+                case "hook_success":
+                case "hook_failure": {
+                    this.finishHookCapture(event.hook);
+                    break;
+                }
+                case "test_fn_start": {
+                    this.startTestCapture(event.test);
+                    break;
+                }
+                case "test_fn_success":
+                case "test_fn_failure": {
+                    this.finishTestCapture(event.test);
+                    break;
+                }
+                case "test_done": {
+                    await this.saveResult(event.test);
+                    break;
+                }
+                case "test_skip": {
+                    this.resetTest();
+                    break;
+                }
+                case "run_finish": {
+                    try {
+                        await this.loadResults();
+                    }
+                    catch (err) {
+                        console.error("Failed to load results in Jest run_finish:", this.formatError(err));
+                    }
+                    finally {
+                        // In worker mode we run local setup, so finalization must happen here even if loadResults fails.
+                        if (!this.finalized) {
+                            this.finalized = true;
+                            try {
+                                await this.strategy.teardown();
+                            }
+                            catch (err) {
+                                console.error("Failed strategy.teardown() in Jest run_finish:", this.formatError(err));
+                            }
+                        }
+                    }
+                    break;
+                }
             }
         }
+        catch (err) {
+            console.error("Unhandled async error in Jest environment event handler:", this.formatError(err));
+        }
+    }
+    formatError(err) {
+        return err?.body ?? err?.error ?? err;
     }
     startHookCapture(hook) {
         log("Starting hook capture %s", hook.type);
@@ -151,7 +219,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
     }
     async saveResult(test) {
         log("Saving result for %s", test.name);
-        await Promise.all(this.attachmentsQueue);
+        await Promise.allSettled(this.attachmentsQueue);
         const errorMessage = test.errors.length > 0 ? test.errors.map((err) => err[0]?.message).join("\n") : undefined;
         const errorTraces = test.errors.length > 0 ? test.errors.map((err) => err[0]?.stack).join("\n") : undefined;
         const result = {
@@ -170,7 +238,7 @@ class TestItEnvironment extends jest_environment_node_1.default {
     }
     async loadResults() {
         log("Waiting for attachments to be uploaded");
-        await Promise.all(this.attachmentsQueue);
+        await Promise.allSettled(this.attachmentsQueue);
         const results = [];
         for (let i = 0; i < this.autotests.length; i++) {
             const autotest = this.autotests[i];
@@ -193,7 +261,12 @@ class TestItEnvironment extends jest_environment_node_1.default {
                 teardown: teardownSteps,
                 externalKey: autotest.externalKey,
             };
-            await this.strategy.loadAutotest(autotestPost, result.outcome);
+            try {
+                await this.strategy.loadAutotest(autotestPost, result.outcome);
+            }
+            catch (err) {
+                console.error("Failed to load autotest in Jest environment:", this.formatError(err));
+            }
             results.push({
                 autoTestExternalId: autotestPost.externalId,
                 outcome: result.outcome,
@@ -210,7 +283,12 @@ class TestItEnvironment extends jest_environment_node_1.default {
             });
         }
         log("Loading results");
-        await this.strategy.loadTestRun(results);
+        try {
+            await this.strategy.loadTestRun(results);
+        }
+        catch (err) {
+            console.error("Failed to load test run in Jest environment:", this.formatError(err));
+        }
     }
     resetTest() {
         this.autotestData = emptyAutotestData();
@@ -252,9 +330,15 @@ class TestItEnvironment extends jest_environment_node_1.default {
         const autotest = this.autotestData;
         const step = this.currentStepData;
         const currentType = this.currentType;
-        // @ts-ignore
-        const promise = this.additions.addAttachments(attachments, name).then((ids) => {
+        // @ts-ignore — overload: paths[] | text content + fileName
+        const promise = this.additions.addAttachments(attachments, name)
+            .then((ids) => {
             currentType === "test" ? autotest.attachments.push(...ids) : step.attachments?.push(...ids);
+            return ids;
+        })
+            .catch((err) => {
+            console.log("Error uploading attachment (Jest). \n", err?.body ?? err?.error ?? err);
+            return [];
         });
         this.attachmentsQueue.push(promise);
         return promise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testit-adapter-jest",
-  "version": "3.7.9",
+  "version": "4.0.0",
   "description": "Jest adapter for Test IT",
   "main": "dist/testitEnvironment.js",
   "scripts": {
@@ -16,7 +16,7 @@
   "license": "ISC",
   "dependencies": {
     "debug": "^4.3.4",
-    "testit-js-commons": "3.7.9"
+    "testit-js-commons": "4.0.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",